// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.nav.sell.order;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.NavSellOrder;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(NavSellOrder.class)
@Setter
@Getter
public class NavSellOrderSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "NavSellOrder".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("shopInfo", "si");
    map.put("site", "sr");
    map.put("createUser", "su");
    map.put("deliveryLogistics", "nlpv");
    map.put("deliveryCountry", "sc");
    map.put("deliveryWarehouse", "w");
    map.put("deliveryLogisticsChannel", "nlcv");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();
    map.put(
      "platform.platform",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_platform AS RO_1 ON RO_1.del_flag = 0 AND RO_1.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_1")
        .setColumnName("platform")
        .setNeedGroupBy(true)
    );
    map.put(
      "platform.platformOrderId",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_platform AS RO_2 ON RO_2.del_flag = 0 AND RO_2.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_2")
        .setColumnName("platform_order_id")
        .setNeedGroupBy(true)
    );
    map.put(
      "product.referenceId",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_detail AS RO_3 ON RO_3.del_flag = 0 AND RO_3.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_3")
        .setColumnName("reference_id")
        .setNeedGroupBy(true)
    );
    map.put(
      "product.msku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_detail AS RO_4 ON RO_4.del_flag = 0 AND RO_4.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_4")
        .setColumnName("msku")
        .setNeedGroupBy(true)
    );
    map.put(
      "product.asin",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_detail AS RO_5 ON RO_5.del_flag = 0 AND RO_5.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_5")
        .setColumnName("asin")
        .setNeedGroupBy(true)
    );
    map.put(
      "product.productName",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_detail AS RO_6 ON RO_6.del_flag = 0 AND RO_6.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_6")
        .setColumnName("product_name")
        .setNeedGroupBy(true)
    );
    map.put(
      "product.sku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_detail AS RO_7 ON RO_7.del_flag = 0 AND RO_7.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_7")
        .setColumnName("sku")
        .setNeedGroupBy(true)
    );
    map.put(
      "platform.purchaseTime",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_platform AS RO_8 ON RO_8.del_flag = 0 AND RO_8.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_8")
        .setColumnName("purchase_time")
        .setNeedGroupBy(true)
    );
    map.put(
      "platform.deliveryTime",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_platform AS RO_9 ON RO_9.del_flag = 0 AND RO_9.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_9")
        .setColumnName("delivery_time")
        .setNeedGroupBy(true)
    );
    map.put(
      "platform.latestShipTime",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN nav_sell_order_platform AS RO_10 ON RO_10.del_flag = 0 AND RO_10.parent_nav_sell_order = t.id"
        )
        .setTableAlias("RO_10")
        .setColumnName("latest_ship_time")
        .setNeedGroupBy(true)
    );

    return map;
  }

  private String platform_platform;
  private List<String> platform_platformInList;
  private String platform_platformOrderId;
  private List<String> platform_platformOrderIdInList;
  private String product_referenceId;
  private List<String> product_referenceIdInList;
  private String product_msku;
  private List<String> product_mskuInList;
  private String product_asin;
  private List<String> product_asinInList;
  private String product_productName;
  private List<String> product_productNameInList;
  private String product_sku;
  private List<String> product_skuInList;

  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private java.util.Date platform_purchaseTime;

  /**
   * 最早订购时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private String platform_purchaseTimeStart;

  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private String platform_purchaseTimeEnd;

  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private java.util.Date platform_deliveryTime;

  /**
   * 最早发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private String platform_deliveryTimeStart;

  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private String platform_deliveryTimeEnd;

  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private java.util.Date platform_latestShipTime;

  /**
   * 最早发货时限
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private String platform_latestShipTimeStart;

  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private String platform_latestShipTimeEnd;

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：NavSellOrder/AllOrder, NavSellOrder/PendingAuditOrder, NavSellOrder/PendingDeliverOrder, NavSellOrder/DeliverOrder, NavSellOrder/NoDeliverOrder, NavSellOrder/PlatformDeliverOrder, NavSellOrder/CanJoinOrder
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 原系统单号(模糊搜索)
   */
  private String originalOrderId;

  /**
   * 原系统单号 比较(eq)
   */
  private String originalOrderIdEq;
  /**
   * 原系统单号 比较(neq)
   */
  private String originalOrderIdNeq;
  /**
   * 原系统单号 比较(gt)
   */
  private String originalOrderIdGt;
  /**
   * 原系统单号 比较(gte)
   */
  private String originalOrderIdGte;
  /**
   * 原系统单号 比较(lt)
   */
  private String originalOrderIdLt;
  /**
   * 原系统单号 比较(lte)
   */
  private String originalOrderIdLte;
  /**
   * 原系统单号 比较(contains)
   */
  private String originalOrderIdContains;
  /**
   * 原系统单号 比较(notcontains)
   */
  private String originalOrderIdNotcontains;
  /**
   * 原系统单号 比较(startswith)
   */
  private String originalOrderIdStartswith;
  /**
   * 原系统单号 比较(endswith)
   */
  private String originalOrderIdEndswith;
  /**
   * 原系统单号 比较(isnull)
   */
  private Boolean originalOrderIdIsnull;
  /**
   * 原系统单号 比较(isnotnull)
   */
  private Boolean originalOrderIdIsnotnull;

  /**
   * 原系统单号(精确搜索)
   */
  private List<String> originalOrderIdInList;

  /**
   * 系统单号(模糊搜索)
   */
  private String orderId;

  /**
   * 系统单号 比较(eq)
   */
  private String orderIdEq;
  /**
   * 系统单号 比较(neq)
   */
  private String orderIdNeq;
  /**
   * 系统单号 比较(gt)
   */
  private String orderIdGt;
  /**
   * 系统单号 比较(gte)
   */
  private String orderIdGte;
  /**
   * 系统单号 比较(lt)
   */
  private String orderIdLt;
  /**
   * 系统单号 比较(lte)
   */
  private String orderIdLte;
  /**
   * 系统单号 比较(contains)
   */
  private String orderIdContains;
  /**
   * 系统单号 比较(notcontains)
   */
  private String orderIdNotcontains;
  /**
   * 系统单号 比较(startswith)
   */
  private String orderIdStartswith;
  /**
   * 系统单号 比较(endswith)
   */
  private String orderIdEndswith;
  /**
   * 系统单号 比较(isnull)
   */
  private Boolean orderIdIsnull;
  /**
   * 系统单号 比较(isnotnull)
   */
  private Boolean orderIdIsnotnull;

  /**
   * 系统单号(精确搜索)
   */
  private List<String> orderIdInList;

  /**
   * 店铺
   */
  private Long shopInfo;

  /**
   * 店铺 比较(eq)
   */
  private Long shopInfoEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopInfoNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopInfoGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopInfoGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopInfoLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopInfoLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopInfoContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopInfoNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopInfoStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopInfoEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopInfoIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopInfoIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopInfoShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopInfoShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopInfoShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopInfoShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopInfoShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopInfoShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopInfoShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopInfoShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopInfoShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopInfoShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopInfoShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopInfoShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopInfoInList;

  /**
   * 币种
   */
  private String currency;

  /**
   * 币种 比较(eq)
   */
  private String currencyEq;
  /**
   * 币种 比较(neq)
   */
  private String currencyNeq;
  /**
   * 币种 比较(gt)
   */
  private String currencyGt;
  /**
   * 币种 比较(gte)
   */
  private String currencyGte;
  /**
   * 币种 比较(lt)
   */
  private String currencyLt;
  /**
   * 币种 比较(lte)
   */
  private String currencyLte;
  /**
   * 币种 比较(contains)
   */
  private String currencyContains;
  /**
   * 币种 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 币种 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 币种(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 订单类型
   */
  private String type;

  /**
   * 订单类型 比较(eq)
   */
  private String typeEq;
  /**
   * 订单类型 比较(neq)
   */
  private String typeNeq;
  /**
   * 订单类型 比较(gt)
   */
  private String typeGt;
  /**
   * 订单类型 比较(gte)
   */
  private String typeGte;
  /**
   * 订单类型 比较(lt)
   */
  private String typeLt;
  /**
   * 订单类型 比较(lte)
   */
  private String typeLte;
  /**
   * 订单类型 比较(contains)
   */
  private String typeContains;
  /**
   * 订单类型 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 订单类型 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 订单类型 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 订单类型 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 订单类型 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 订单类型(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 站点
   */
  private Long site;

  /**
   * 站点 比较(eq)
   */
  private Long siteEq;
  /**
   * 站点 比较(neq)
   */
  private Long siteNeq;
  /**
   * 站点 比较(gt)
   */
  private Long siteGt;
  /**
   * 站点 比较(gte)
   */
  private Long siteGte;
  /**
   * 站点 比较(lt)
   */
  private Long siteLt;
  /**
   * 站点 比较(lte)
   */
  private Long siteLte;
  /**
   * 站点 比较(contains)
   */
  private Long siteContains;
  /**
   * 站点 比较(notcontains)
   */
  private Long siteNotcontains;
  /**
   * 站点 比较(startswith)
   */
  private Long siteStartswith;
  /**
   * 站点 比较(endswith)
   */
  private Long siteEndswith;
  /**
   * 站点 比较(isnull)
   */
  private Boolean siteIsnull;
  /**
   * 站点 比较(isnotnull)
   */
  private Boolean siteIsnotnull;
  /**
   * 站点的名称 比较(eq)
   */
  private String siteNameEq;
  /**
   * 站点的名称 比较(neq)
   */
  private String siteNameNeq;
  /**
   * 站点的名称 比较(gt)
   */
  private String siteNameGt;
  /**
   * 站点的名称 比较(gte)
   */
  private String siteNameGte;
  /**
   * 站点的名称 比较(lt)
   */
  private String siteNameLt;
  /**
   * 站点的名称 比较(lte)
   */
  private String siteNameLte;
  /**
   * 站点的名称 比较(contains)
   */
  private String siteNameContains;
  /**
   * 站点的名称 比较(notcontains)
   */
  private String siteNameNotcontains;
  /**
   * 站点的名称 比较(startswith)
   */
  private String siteNameStartswith;
  /**
   * 站点的名称 比较(endswith)
   */
  private String siteNameEndswith;
  /**
   * 站点的名称 比较(isnull)
   */
  private Boolean siteNameIsnull;
  /**
   * 站点的名称 比较(isnotnull)
   */
  private Boolean siteNameIsnotnull;

  /**
   * 站点(范围搜索)
   */
  private List<Long> siteInList;

  /**
   * 订单标签
   */
  private String tag;

  /**
   * 订单标签 比较(eq)
   */
  private String tagEq;
  /**
   * 订单标签 比较(neq)
   */
  private String tagNeq;
  /**
   * 订单标签 比较(gt)
   */
  private String tagGt;
  /**
   * 订单标签 比较(gte)
   */
  private String tagGte;
  /**
   * 订单标签 比较(lt)
   */
  private String tagLt;
  /**
   * 订单标签 比较(lte)
   */
  private String tagLte;
  /**
   * 订单标签 比较(contains)
   */
  private String tagContains;
  /**
   * 订单标签 比较(notcontains)
   */
  private String tagNotcontains;
  /**
   * 订单标签 比较(startswith)
   */
  private String tagStartswith;
  /**
   * 订单标签 比较(endswith)
   */
  private String tagEndswith;
  /**
   * 订单标签 比较(isnull)
   */
  private Boolean tagIsnull;
  /**
   * 订单标签 比较(isnotnull)
   */
  private Boolean tagIsnotnull;

  /**
   * 订单标签(精确搜索)
   */
  private List<String> tagInList;

  /**
   * 订单来源
   */
  private String source;

  /**
   * 订单来源 比较(eq)
   */
  private String sourceEq;
  /**
   * 订单来源 比较(neq)
   */
  private String sourceNeq;
  /**
   * 订单来源 比较(gt)
   */
  private String sourceGt;
  /**
   * 订单来源 比较(gte)
   */
  private String sourceGte;
  /**
   * 订单来源 比较(lt)
   */
  private String sourceLt;
  /**
   * 订单来源 比较(lte)
   */
  private String sourceLte;
  /**
   * 订单来源 比较(contains)
   */
  private String sourceContains;
  /**
   * 订单来源 比较(notcontains)
   */
  private String sourceNotcontains;
  /**
   * 订单来源 比较(startswith)
   */
  private String sourceStartswith;
  /**
   * 订单来源 比较(endswith)
   */
  private String sourceEndswith;
  /**
   * 订单来源 比较(isnull)
   */
  private Boolean sourceIsnull;
  /**
   * 订单来源 比较(isnotnull)
   */
  private Boolean sourceIsnotnull;

  /**
   * 订单来源(精确搜索)
   */
  private List<String> sourceInList;

  /**
   * 是否有 附件
   */
  private Boolean files;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 拆分订单类型
   */
  private String splitType;

  /**
   * 拆分订单类型 比较(eq)
   */
  private String splitTypeEq;
  /**
   * 拆分订单类型 比较(neq)
   */
  private String splitTypeNeq;
  /**
   * 拆分订单类型 比较(gt)
   */
  private String splitTypeGt;
  /**
   * 拆分订单类型 比较(gte)
   */
  private String splitTypeGte;
  /**
   * 拆分订单类型 比较(lt)
   */
  private String splitTypeLt;
  /**
   * 拆分订单类型 比较(lte)
   */
  private String splitTypeLte;
  /**
   * 拆分订单类型 比较(contains)
   */
  private String splitTypeContains;
  /**
   * 拆分订单类型 比较(notcontains)
   */
  private String splitTypeNotcontains;
  /**
   * 拆分订单类型 比较(startswith)
   */
  private String splitTypeStartswith;
  /**
   * 拆分订单类型 比较(endswith)
   */
  private String splitTypeEndswith;
  /**
   * 拆分订单类型 比较(isnull)
   */
  private Boolean splitTypeIsnull;
  /**
   * 拆分订单类型 比较(isnotnull)
   */
  private Boolean splitTypeIsnotnull;

  /**
   * 拆分订单类型(精确搜索)
   */
  private List<String> splitTypeInList;

  /**
   * 客服备注(模糊搜索)
   */
  private String remark;

  /**
   * 客服备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 客服备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 客服备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 客服备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 客服备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 客服备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 客服备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 客服备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 客服备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 客服备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 客服备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 客服备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 客服备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;
  /**
   * 创建人的显示用户名 比较(eq)
   */
  private String createUserNameEq;
  /**
   * 创建人的显示用户名 比较(neq)
   */
  private String createUserNameNeq;
  /**
   * 创建人的显示用户名 比较(gt)
   */
  private String createUserNameGt;
  /**
   * 创建人的显示用户名 比较(gte)
   */
  private String createUserNameGte;
  /**
   * 创建人的显示用户名 比较(lt)
   */
  private String createUserNameLt;
  /**
   * 创建人的显示用户名 比较(lte)
   */
  private String createUserNameLte;
  /**
   * 创建人的显示用户名 比较(contains)
   */
  private String createUserNameContains;
  /**
   * 创建人的显示用户名 比较(notcontains)
   */
  private String createUserNameNotcontains;
  /**
   * 创建人的显示用户名 比较(startswith)
   */
  private String createUserNameStartswith;
  /**
   * 创建人的显示用户名 比较(endswith)
   */
  private String createUserNameEndswith;
  /**
   * 创建人的显示用户名 比较(isnull)
   */
  private Boolean createUserNameIsnull;
  /**
   * 创建人的显示用户名 比较(isnotnull)
   */
  private Boolean createUserNameIsnotnull;

  /**
   * 创建人(范围搜索)
   */
  private List<Long> createUserInList;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 支付方式
   */
  private String paymentWay;

  /**
   * 支付方式 比较(eq)
   */
  private String paymentWayEq;
  /**
   * 支付方式 比较(neq)
   */
  private String paymentWayNeq;
  /**
   * 支付方式 比较(gt)
   */
  private String paymentWayGt;
  /**
   * 支付方式 比较(gte)
   */
  private String paymentWayGte;
  /**
   * 支付方式 比较(lt)
   */
  private String paymentWayLt;
  /**
   * 支付方式 比较(lte)
   */
  private String paymentWayLte;
  /**
   * 支付方式 比较(contains)
   */
  private String paymentWayContains;
  /**
   * 支付方式 比较(notcontains)
   */
  private String paymentWayNotcontains;
  /**
   * 支付方式 比较(startswith)
   */
  private String paymentWayStartswith;
  /**
   * 支付方式 比较(endswith)
   */
  private String paymentWayEndswith;
  /**
   * 支付方式 比较(isnull)
   */
  private Boolean paymentWayIsnull;
  /**
   * 支付方式 比较(isnotnull)
   */
  private Boolean paymentWayIsnotnull;

  /**
   * 支付方式(精确搜索)
   */
  private List<String> paymentWayInList;

  /**
   * 买家姓名(模糊搜索)
   */
  private String buyerName;

  /**
   * 买家姓名 比较(eq)
   */
  private String buyerNameEq;
  /**
   * 买家姓名 比较(neq)
   */
  private String buyerNameNeq;
  /**
   * 买家姓名 比较(gt)
   */
  private String buyerNameGt;
  /**
   * 买家姓名 比较(gte)
   */
  private String buyerNameGte;
  /**
   * 买家姓名 比较(lt)
   */
  private String buyerNameLt;
  /**
   * 买家姓名 比较(lte)
   */
  private String buyerNameLte;
  /**
   * 买家姓名 比较(contains)
   */
  private String buyerNameContains;
  /**
   * 买家姓名 比较(notcontains)
   */
  private String buyerNameNotcontains;
  /**
   * 买家姓名 比较(startswith)
   */
  private String buyerNameStartswith;
  /**
   * 买家姓名 比较(endswith)
   */
  private String buyerNameEndswith;
  /**
   * 买家姓名 比较(isnull)
   */
  private Boolean buyerNameIsnull;
  /**
   * 买家姓名 比较(isnotnull)
   */
  private Boolean buyerNameIsnotnull;

  /**
   * 买家姓名(精确搜索)
   */
  private List<String> buyerNameInList;

  /**
   * 买家邮箱(模糊搜索)
   */
  private String buyerEmail;

  /**
   * 买家邮箱 比较(eq)
   */
  private String buyerEmailEq;
  /**
   * 买家邮箱 比较(neq)
   */
  private String buyerEmailNeq;
  /**
   * 买家邮箱 比较(gt)
   */
  private String buyerEmailGt;
  /**
   * 买家邮箱 比较(gte)
   */
  private String buyerEmailGte;
  /**
   * 买家邮箱 比较(lt)
   */
  private String buyerEmailLt;
  /**
   * 买家邮箱 比较(lte)
   */
  private String buyerEmailLte;
  /**
   * 买家邮箱 比较(contains)
   */
  private String buyerEmailContains;
  /**
   * 买家邮箱 比较(notcontains)
   */
  private String buyerEmailNotcontains;
  /**
   * 买家邮箱 比较(startswith)
   */
  private String buyerEmailStartswith;
  /**
   * 买家邮箱 比较(endswith)
   */
  private String buyerEmailEndswith;
  /**
   * 买家邮箱 比较(isnull)
   */
  private Boolean buyerEmailIsnull;
  /**
   * 买家邮箱 比较(isnotnull)
   */
  private Boolean buyerEmailIsnotnull;

  /**
   * 买家邮箱(精确搜索)
   */
  private List<String> buyerEmailInList;

  /**
   * 客选物流
   */
  private Long deliveryLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long deliveryLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long deliveryLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long deliveryLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long deliveryLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long deliveryLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long deliveryLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long deliveryLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long deliveryLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long deliveryLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long deliveryLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean deliveryLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean deliveryLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String deliveryLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String deliveryLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String deliveryLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String deliveryLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String deliveryLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String deliveryLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String deliveryLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String deliveryLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String deliveryLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String deliveryLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean deliveryLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean deliveryLogisticsLabelIsnotnull;

  /**
   * 客选物流(范围搜索)
   */
  private List<Long> deliveryLogisticsInList;

  /**
   * 买家留言(模糊搜索)
   */
  private String buyerLeaveWord;

  /**
   * 买家留言 比较(eq)
   */
  private String buyerLeaveWordEq;
  /**
   * 买家留言 比较(neq)
   */
  private String buyerLeaveWordNeq;
  /**
   * 买家留言 比较(gt)
   */
  private String buyerLeaveWordGt;
  /**
   * 买家留言 比较(gte)
   */
  private String buyerLeaveWordGte;
  /**
   * 买家留言 比较(lt)
   */
  private String buyerLeaveWordLt;
  /**
   * 买家留言 比较(lte)
   */
  private String buyerLeaveWordLte;
  /**
   * 买家留言 比较(contains)
   */
  private String buyerLeaveWordContains;
  /**
   * 买家留言 比较(notcontains)
   */
  private String buyerLeaveWordNotcontains;
  /**
   * 买家留言 比较(startswith)
   */
  private String buyerLeaveWordStartswith;
  /**
   * 买家留言 比较(endswith)
   */
  private String buyerLeaveWordEndswith;
  /**
   * 买家留言 比较(isnull)
   */
  private Boolean buyerLeaveWordIsnull;
  /**
   * 买家留言 比较(isnotnull)
   */
  private Boolean buyerLeaveWordIsnotnull;

  /**
   * 买家留言(精确搜索)
   */
  private List<String> buyerLeaveWordInList;

  /**
   * 收件人(模糊搜索)
   */
  private String deliveryReceipt;

  /**
   * 收件人 比较(eq)
   */
  private String deliveryReceiptEq;
  /**
   * 收件人 比较(neq)
   */
  private String deliveryReceiptNeq;
  /**
   * 收件人 比较(gt)
   */
  private String deliveryReceiptGt;
  /**
   * 收件人 比较(gte)
   */
  private String deliveryReceiptGte;
  /**
   * 收件人 比较(lt)
   */
  private String deliveryReceiptLt;
  /**
   * 收件人 比较(lte)
   */
  private String deliveryReceiptLte;
  /**
   * 收件人 比较(contains)
   */
  private String deliveryReceiptContains;
  /**
   * 收件人 比较(notcontains)
   */
  private String deliveryReceiptNotcontains;
  /**
   * 收件人 比较(startswith)
   */
  private String deliveryReceiptStartswith;
  /**
   * 收件人 比较(endswith)
   */
  private String deliveryReceiptEndswith;
  /**
   * 收件人 比较(isnull)
   */
  private Boolean deliveryReceiptIsnull;
  /**
   * 收件人 比较(isnotnull)
   */
  private Boolean deliveryReceiptIsnotnull;

  /**
   * 收件人(精确搜索)
   */
  private List<String> deliveryReceiptInList;

  /**
   * 邮编(模糊搜索)
   */
  private String deliveryZipCode;

  /**
   * 邮编 比较(eq)
   */
  private String deliveryZipCodeEq;
  /**
   * 邮编 比较(neq)
   */
  private String deliveryZipCodeNeq;
  /**
   * 邮编 比较(gt)
   */
  private String deliveryZipCodeGt;
  /**
   * 邮编 比较(gte)
   */
  private String deliveryZipCodeGte;
  /**
   * 邮编 比较(lt)
   */
  private String deliveryZipCodeLt;
  /**
   * 邮编 比较(lte)
   */
  private String deliveryZipCodeLte;
  /**
   * 邮编 比较(contains)
   */
  private String deliveryZipCodeContains;
  /**
   * 邮编 比较(notcontains)
   */
  private String deliveryZipCodeNotcontains;
  /**
   * 邮编 比较(startswith)
   */
  private String deliveryZipCodeStartswith;
  /**
   * 邮编 比较(endswith)
   */
  private String deliveryZipCodeEndswith;
  /**
   * 邮编 比较(isnull)
   */
  private Boolean deliveryZipCodeIsnull;
  /**
   * 邮编 比较(isnotnull)
   */
  private Boolean deliveryZipCodeIsnotnull;

  /**
   * 邮编(精确搜索)
   */
  private List<String> deliveryZipCodeInList;

  /**
   * 电话(模糊搜索)
   */
  private String deliveryPhone;

  /**
   * 电话 比较(eq)
   */
  private String deliveryPhoneEq;
  /**
   * 电话 比较(neq)
   */
  private String deliveryPhoneNeq;
  /**
   * 电话 比较(gt)
   */
  private String deliveryPhoneGt;
  /**
   * 电话 比较(gte)
   */
  private String deliveryPhoneGte;
  /**
   * 电话 比较(lt)
   */
  private String deliveryPhoneLt;
  /**
   * 电话 比较(lte)
   */
  private String deliveryPhoneLte;
  /**
   * 电话 比较(contains)
   */
  private String deliveryPhoneContains;
  /**
   * 电话 比较(notcontains)
   */
  private String deliveryPhoneNotcontains;
  /**
   * 电话 比较(startswith)
   */
  private String deliveryPhoneStartswith;
  /**
   * 电话 比较(endswith)
   */
  private String deliveryPhoneEndswith;
  /**
   * 电话 比较(isnull)
   */
  private Boolean deliveryPhoneIsnull;
  /**
   * 电话 比较(isnotnull)
   */
  private Boolean deliveryPhoneIsnotnull;

  /**
   * 电话(精确搜索)
   */
  private List<String> deliveryPhoneInList;

  /**
   * 国家/地区
   */
  private Long deliveryCountry;

  /**
   * 国家/地区 比较(eq)
   */
  private Long deliveryCountryEq;
  /**
   * 国家/地区 比较(neq)
   */
  private Long deliveryCountryNeq;
  /**
   * 国家/地区 比较(gt)
   */
  private Long deliveryCountryGt;
  /**
   * 国家/地区 比较(gte)
   */
  private Long deliveryCountryGte;
  /**
   * 国家/地区 比较(lt)
   */
  private Long deliveryCountryLt;
  /**
   * 国家/地区 比较(lte)
   */
  private Long deliveryCountryLte;
  /**
   * 国家/地区 比较(contains)
   */
  private Long deliveryCountryContains;
  /**
   * 国家/地区 比较(notcontains)
   */
  private Long deliveryCountryNotcontains;
  /**
   * 国家/地区 比较(startswith)
   */
  private Long deliveryCountryStartswith;
  /**
   * 国家/地区 比较(endswith)
   */
  private Long deliveryCountryEndswith;
  /**
   * 国家/地区 比较(isnull)
   */
  private Boolean deliveryCountryIsnull;
  /**
   * 国家/地区 比较(isnotnull)
   */
  private Boolean deliveryCountryIsnotnull;
  /**
   * 国家/地区的国家 比较(eq)
   */
  private String deliveryCountryCountryEq;
  /**
   * 国家/地区的国家 比较(neq)
   */
  private String deliveryCountryCountryNeq;
  /**
   * 国家/地区的国家 比较(gt)
   */
  private String deliveryCountryCountryGt;
  /**
   * 国家/地区的国家 比较(gte)
   */
  private String deliveryCountryCountryGte;
  /**
   * 国家/地区的国家 比较(lt)
   */
  private String deliveryCountryCountryLt;
  /**
   * 国家/地区的国家 比较(lte)
   */
  private String deliveryCountryCountryLte;
  /**
   * 国家/地区的国家 比较(contains)
   */
  private String deliveryCountryCountryContains;
  /**
   * 国家/地区的国家 比较(notcontains)
   */
  private String deliveryCountryCountryNotcontains;
  /**
   * 国家/地区的国家 比较(startswith)
   */
  private String deliveryCountryCountryStartswith;
  /**
   * 国家/地区的国家 比较(endswith)
   */
  private String deliveryCountryCountryEndswith;
  /**
   * 国家/地区的国家 比较(isnull)
   */
  private Boolean deliveryCountryCountryIsnull;
  /**
   * 国家/地区的国家 比较(isnotnull)
   */
  private Boolean deliveryCountryCountryIsnotnull;

  /**
   * 国家/地区(范围搜索)
   */
  private List<Long> deliveryCountryInList;

  /**
   * 省/州(模糊搜索)
   */
  private String deliveryProvince;

  /**
   * 省/州 比较(eq)
   */
  private String deliveryProvinceEq;
  /**
   * 省/州 比较(neq)
   */
  private String deliveryProvinceNeq;
  /**
   * 省/州 比较(gt)
   */
  private String deliveryProvinceGt;
  /**
   * 省/州 比较(gte)
   */
  private String deliveryProvinceGte;
  /**
   * 省/州 比较(lt)
   */
  private String deliveryProvinceLt;
  /**
   * 省/州 比较(lte)
   */
  private String deliveryProvinceLte;
  /**
   * 省/州 比较(contains)
   */
  private String deliveryProvinceContains;
  /**
   * 省/州 比较(notcontains)
   */
  private String deliveryProvinceNotcontains;
  /**
   * 省/州 比较(startswith)
   */
  private String deliveryProvinceStartswith;
  /**
   * 省/州 比较(endswith)
   */
  private String deliveryProvinceEndswith;
  /**
   * 省/州 比较(isnull)
   */
  private Boolean deliveryProvinceIsnull;
  /**
   * 省/州 比较(isnotnull)
   */
  private Boolean deliveryProvinceIsnotnull;

  /**
   * 省/州(精确搜索)
   */
  private List<String> deliveryProvinceInList;

  /**
   * 城市(模糊搜索)
   */
  private String deliveryCity;

  /**
   * 城市 比较(eq)
   */
  private String deliveryCityEq;
  /**
   * 城市 比较(neq)
   */
  private String deliveryCityNeq;
  /**
   * 城市 比较(gt)
   */
  private String deliveryCityGt;
  /**
   * 城市 比较(gte)
   */
  private String deliveryCityGte;
  /**
   * 城市 比较(lt)
   */
  private String deliveryCityLt;
  /**
   * 城市 比较(lte)
   */
  private String deliveryCityLte;
  /**
   * 城市 比较(contains)
   */
  private String deliveryCityContains;
  /**
   * 城市 比较(notcontains)
   */
  private String deliveryCityNotcontains;
  /**
   * 城市 比较(startswith)
   */
  private String deliveryCityStartswith;
  /**
   * 城市 比较(endswith)
   */
  private String deliveryCityEndswith;
  /**
   * 城市 比较(isnull)
   */
  private Boolean deliveryCityIsnull;
  /**
   * 城市 比较(isnotnull)
   */
  private Boolean deliveryCityIsnotnull;

  /**
   * 城市(精确搜索)
   */
  private List<String> deliveryCityInList;

  /**
   * 区/县(模糊搜索)
   */
  private String deliveryArea;

  /**
   * 区/县 比较(eq)
   */
  private String deliveryAreaEq;
  /**
   * 区/县 比较(neq)
   */
  private String deliveryAreaNeq;
  /**
   * 区/县 比较(gt)
   */
  private String deliveryAreaGt;
  /**
   * 区/县 比较(gte)
   */
  private String deliveryAreaGte;
  /**
   * 区/县 比较(lt)
   */
  private String deliveryAreaLt;
  /**
   * 区/县 比较(lte)
   */
  private String deliveryAreaLte;
  /**
   * 区/县 比较(contains)
   */
  private String deliveryAreaContains;
  /**
   * 区/县 比较(notcontains)
   */
  private String deliveryAreaNotcontains;
  /**
   * 区/县 比较(startswith)
   */
  private String deliveryAreaStartswith;
  /**
   * 区/县 比较(endswith)
   */
  private String deliveryAreaEndswith;
  /**
   * 区/县 比较(isnull)
   */
  private Boolean deliveryAreaIsnull;
  /**
   * 区/县 比较(isnotnull)
   */
  private Boolean deliveryAreaIsnotnull;

  /**
   * 区/县(精确搜索)
   */
  private List<String> deliveryAreaInList;

  /**
   * 门牌号(模糊搜索)
   */
  private String deliveryHouseNumber;

  /**
   * 门牌号 比较(eq)
   */
  private String deliveryHouseNumberEq;
  /**
   * 门牌号 比较(neq)
   */
  private String deliveryHouseNumberNeq;
  /**
   * 门牌号 比较(gt)
   */
  private String deliveryHouseNumberGt;
  /**
   * 门牌号 比较(gte)
   */
  private String deliveryHouseNumberGte;
  /**
   * 门牌号 比较(lt)
   */
  private String deliveryHouseNumberLt;
  /**
   * 门牌号 比较(lte)
   */
  private String deliveryHouseNumberLte;
  /**
   * 门牌号 比较(contains)
   */
  private String deliveryHouseNumberContains;
  /**
   * 门牌号 比较(notcontains)
   */
  private String deliveryHouseNumberNotcontains;
  /**
   * 门牌号 比较(startswith)
   */
  private String deliveryHouseNumberStartswith;
  /**
   * 门牌号 比较(endswith)
   */
  private String deliveryHouseNumberEndswith;
  /**
   * 门牌号 比较(isnull)
   */
  private Boolean deliveryHouseNumberIsnull;
  /**
   * 门牌号 比较(isnotnull)
   */
  private Boolean deliveryHouseNumberIsnotnull;

  /**
   * 门牌号(精确搜索)
   */
  private List<String> deliveryHouseNumberInList;

  /**
   * 公司名(模糊搜索)
   */
  private String deliveryCompany;

  /**
   * 公司名 比较(eq)
   */
  private String deliveryCompanyEq;
  /**
   * 公司名 比较(neq)
   */
  private String deliveryCompanyNeq;
  /**
   * 公司名 比较(gt)
   */
  private String deliveryCompanyGt;
  /**
   * 公司名 比较(gte)
   */
  private String deliveryCompanyGte;
  /**
   * 公司名 比较(lt)
   */
  private String deliveryCompanyLt;
  /**
   * 公司名 比较(lte)
   */
  private String deliveryCompanyLte;
  /**
   * 公司名 比较(contains)
   */
  private String deliveryCompanyContains;
  /**
   * 公司名 比较(notcontains)
   */
  private String deliveryCompanyNotcontains;
  /**
   * 公司名 比较(startswith)
   */
  private String deliveryCompanyStartswith;
  /**
   * 公司名 比较(endswith)
   */
  private String deliveryCompanyEndswith;
  /**
   * 公司名 比较(isnull)
   */
  private Boolean deliveryCompanyIsnull;
  /**
   * 公司名 比较(isnotnull)
   */
  private Boolean deliveryCompanyIsnotnull;

  /**
   * 公司名(精确搜索)
   */
  private List<String> deliveryCompanyInList;

  /**
   * 地址类型
   */
  private String deliveryAddressType;

  /**
   * 地址类型 比较(eq)
   */
  private String deliveryAddressTypeEq;
  /**
   * 地址类型 比较(neq)
   */
  private String deliveryAddressTypeNeq;
  /**
   * 地址类型 比较(gt)
   */
  private String deliveryAddressTypeGt;
  /**
   * 地址类型 比较(gte)
   */
  private String deliveryAddressTypeGte;
  /**
   * 地址类型 比较(lt)
   */
  private String deliveryAddressTypeLt;
  /**
   * 地址类型 比较(lte)
   */
  private String deliveryAddressTypeLte;
  /**
   * 地址类型 比较(contains)
   */
  private String deliveryAddressTypeContains;
  /**
   * 地址类型 比较(notcontains)
   */
  private String deliveryAddressTypeNotcontains;
  /**
   * 地址类型 比较(startswith)
   */
  private String deliveryAddressTypeStartswith;
  /**
   * 地址类型 比较(endswith)
   */
  private String deliveryAddressTypeEndswith;
  /**
   * 地址类型 比较(isnull)
   */
  private Boolean deliveryAddressTypeIsnull;
  /**
   * 地址类型 比较(isnotnull)
   */
  private Boolean deliveryAddressTypeIsnotnull;

  /**
   * 地址类型(精确搜索)
   */
  private List<String> deliveryAddressTypeInList;

  /**
   * 详细地址1(模糊搜索)
   */
  private String deliveryAddress1;

  /**
   * 详细地址1 比较(eq)
   */
  private String deliveryAddress1Eq;
  /**
   * 详细地址1 比较(neq)
   */
  private String deliveryAddress1Neq;
  /**
   * 详细地址1 比较(gt)
   */
  private String deliveryAddress1Gt;
  /**
   * 详细地址1 比较(gte)
   */
  private String deliveryAddress1Gte;
  /**
   * 详细地址1 比较(lt)
   */
  private String deliveryAddress1Lt;
  /**
   * 详细地址1 比较(lte)
   */
  private String deliveryAddress1Lte;
  /**
   * 详细地址1 比较(contains)
   */
  private String deliveryAddress1Contains;
  /**
   * 详细地址1 比较(notcontains)
   */
  private String deliveryAddress1Notcontains;
  /**
   * 详细地址1 比较(startswith)
   */
  private String deliveryAddress1Startswith;
  /**
   * 详细地址1 比较(endswith)
   */
  private String deliveryAddress1Endswith;
  /**
   * 详细地址1 比较(isnull)
   */
  private Boolean deliveryAddress1Isnull;
  /**
   * 详细地址1 比较(isnotnull)
   */
  private Boolean deliveryAddress1Isnotnull;

  /**
   * 详细地址1(精确搜索)
   */
  private List<String> deliveryAddress1InList;

  /**
   * 详细地址2(模糊搜索)
   */
  private String deliveryAddress2;

  /**
   * 详细地址2 比较(eq)
   */
  private String deliveryAddress2Eq;
  /**
   * 详细地址2 比较(neq)
   */
  private String deliveryAddress2Neq;
  /**
   * 详细地址2 比较(gt)
   */
  private String deliveryAddress2Gt;
  /**
   * 详细地址2 比较(gte)
   */
  private String deliveryAddress2Gte;
  /**
   * 详细地址2 比较(lt)
   */
  private String deliveryAddress2Lt;
  /**
   * 详细地址2 比较(lte)
   */
  private String deliveryAddress2Lte;
  /**
   * 详细地址2 比较(contains)
   */
  private String deliveryAddress2Contains;
  /**
   * 详细地址2 比较(notcontains)
   */
  private String deliveryAddress2Notcontains;
  /**
   * 详细地址2 比较(startswith)
   */
  private String deliveryAddress2Startswith;
  /**
   * 详细地址2 比较(endswith)
   */
  private String deliveryAddress2Endswith;
  /**
   * 详细地址2 比较(isnull)
   */
  private Boolean deliveryAddress2Isnull;
  /**
   * 详细地址2 比较(isnotnull)
   */
  private Boolean deliveryAddress2Isnotnull;

  /**
   * 详细地址2(精确搜索)
   */
  private List<String> deliveryAddress2InList;

  /**
   * 详细地址3(模糊搜索)
   */
  private String deliveryAddress3;

  /**
   * 详细地址3 比较(eq)
   */
  private String deliveryAddress3Eq;
  /**
   * 详细地址3 比较(neq)
   */
  private String deliveryAddress3Neq;
  /**
   * 详细地址3 比较(gt)
   */
  private String deliveryAddress3Gt;
  /**
   * 详细地址3 比较(gte)
   */
  private String deliveryAddress3Gte;
  /**
   * 详细地址3 比较(lt)
   */
  private String deliveryAddress3Lt;
  /**
   * 详细地址3 比较(lte)
   */
  private String deliveryAddress3Lte;
  /**
   * 详细地址3 比较(contains)
   */
  private String deliveryAddress3Contains;
  /**
   * 详细地址3 比较(notcontains)
   */
  private String deliveryAddress3Notcontains;
  /**
   * 详细地址3 比较(startswith)
   */
  private String deliveryAddress3Startswith;
  /**
   * 详细地址3 比较(endswith)
   */
  private String deliveryAddress3Endswith;
  /**
   * 详细地址3 比较(isnull)
   */
  private Boolean deliveryAddress3Isnull;
  /**
   * 详细地址3 比较(isnotnull)
   */
  private Boolean deliveryAddress3Isnotnull;

  /**
   * 详细地址3(精确搜索)
   */
  private List<String> deliveryAddress3InList;

  /**
   * 发货仓属性
   */
  private String deliveryWidType;

  /**
   * 发货仓属性 比较(eq)
   */
  private String deliveryWidTypeEq;
  /**
   * 发货仓属性 比较(neq)
   */
  private String deliveryWidTypeNeq;
  /**
   * 发货仓属性 比较(gt)
   */
  private String deliveryWidTypeGt;
  /**
   * 发货仓属性 比较(gte)
   */
  private String deliveryWidTypeGte;
  /**
   * 发货仓属性 比较(lt)
   */
  private String deliveryWidTypeLt;
  /**
   * 发货仓属性 比较(lte)
   */
  private String deliveryWidTypeLte;
  /**
   * 发货仓属性 比较(contains)
   */
  private String deliveryWidTypeContains;
  /**
   * 发货仓属性 比较(notcontains)
   */
  private String deliveryWidTypeNotcontains;
  /**
   * 发货仓属性 比较(startswith)
   */
  private String deliveryWidTypeStartswith;
  /**
   * 发货仓属性 比较(endswith)
   */
  private String deliveryWidTypeEndswith;
  /**
   * 发货仓属性 比较(isnull)
   */
  private Boolean deliveryWidTypeIsnull;
  /**
   * 发货仓属性 比较(isnotnull)
   */
  private Boolean deliveryWidTypeIsnotnull;

  /**
   * 发货仓属性(精确搜索)
   */
  private List<String> deliveryWidTypeInList;

  /**
   * 发货仓库
   */
  private Long deliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long deliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long deliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long deliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long deliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long deliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long deliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long deliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long deliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long deliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long deliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean deliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean deliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String deliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String deliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String deliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String deliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String deliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String deliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String deliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String deliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String deliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String deliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean deliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean deliveryWarehouseNameIsnotnull;

  /**
   * 发货仓库(范围搜索)
   */
  private List<Long> deliveryWarehouseInList;

  /**
   * 物流方式
   */
  private Long deliveryLogisticsChannel;

  /**
   * 物流方式 比较(eq)
   */
  private Long deliveryLogisticsChannelEq;
  /**
   * 物流方式 比较(neq)
   */
  private Long deliveryLogisticsChannelNeq;
  /**
   * 物流方式 比较(gt)
   */
  private Long deliveryLogisticsChannelGt;
  /**
   * 物流方式 比较(gte)
   */
  private Long deliveryLogisticsChannelGte;
  /**
   * 物流方式 比较(lt)
   */
  private Long deliveryLogisticsChannelLt;
  /**
   * 物流方式 比较(lte)
   */
  private Long deliveryLogisticsChannelLte;
  /**
   * 物流方式 比较(contains)
   */
  private Long deliveryLogisticsChannelContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private Long deliveryLogisticsChannelNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private Long deliveryLogisticsChannelStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private Long deliveryLogisticsChannelEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean deliveryLogisticsChannelIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean deliveryLogisticsChannelIsnotnull;
  /**
   * 物流方式的名称 比较(eq)
   */
  private String deliveryLogisticsChannelLabelEq;
  /**
   * 物流方式的名称 比较(neq)
   */
  private String deliveryLogisticsChannelLabelNeq;
  /**
   * 物流方式的名称 比较(gt)
   */
  private String deliveryLogisticsChannelLabelGt;
  /**
   * 物流方式的名称 比较(gte)
   */
  private String deliveryLogisticsChannelLabelGte;
  /**
   * 物流方式的名称 比较(lt)
   */
  private String deliveryLogisticsChannelLabelLt;
  /**
   * 物流方式的名称 比较(lte)
   */
  private String deliveryLogisticsChannelLabelLte;
  /**
   * 物流方式的名称 比较(contains)
   */
  private String deliveryLogisticsChannelLabelContains;
  /**
   * 物流方式的名称 比较(notcontains)
   */
  private String deliveryLogisticsChannelLabelNotcontains;
  /**
   * 物流方式的名称 比较(startswith)
   */
  private String deliveryLogisticsChannelLabelStartswith;
  /**
   * 物流方式的名称 比较(endswith)
   */
  private String deliveryLogisticsChannelLabelEndswith;
  /**
   * 物流方式的名称 比较(isnull)
   */
  private Boolean deliveryLogisticsChannelLabelIsnull;
  /**
   * 物流方式的名称 比较(isnotnull)
   */
  private Boolean deliveryLogisticsChannelLabelIsnotnull;

  /**
   * 物流方式(范围搜索)
   */
  private List<Long> deliveryLogisticsChannelInList;

  /**
   * 运单号(模糊搜索)
   */
  private String deliveryWaybillId;

  /**
   * 运单号 比较(eq)
   */
  private String deliveryWaybillIdEq;
  /**
   * 运单号 比较(neq)
   */
  private String deliveryWaybillIdNeq;
  /**
   * 运单号 比较(gt)
   */
  private String deliveryWaybillIdGt;
  /**
   * 运单号 比较(gte)
   */
  private String deliveryWaybillIdGte;
  /**
   * 运单号 比较(lt)
   */
  private String deliveryWaybillIdLt;
  /**
   * 运单号 比较(lte)
   */
  private String deliveryWaybillIdLte;
  /**
   * 运单号 比较(contains)
   */
  private String deliveryWaybillIdContains;
  /**
   * 运单号 比较(notcontains)
   */
  private String deliveryWaybillIdNotcontains;
  /**
   * 运单号 比较(startswith)
   */
  private String deliveryWaybillIdStartswith;
  /**
   * 运单号 比较(endswith)
   */
  private String deliveryWaybillIdEndswith;
  /**
   * 运单号 比较(isnull)
   */
  private Boolean deliveryWaybillIdIsnull;
  /**
   * 运单号 比较(isnotnull)
   */
  private Boolean deliveryWaybillIdIsnotnull;

  /**
   * 运单号(精确搜索)
   */
  private List<String> deliveryWaybillIdInList;

  /**
   * 跟踪号(模糊搜索)
   */
  private String deliveryTrackId;

  /**
   * 跟踪号 比较(eq)
   */
  private String deliveryTrackIdEq;
  /**
   * 跟踪号 比较(neq)
   */
  private String deliveryTrackIdNeq;
  /**
   * 跟踪号 比较(gt)
   */
  private String deliveryTrackIdGt;
  /**
   * 跟踪号 比较(gte)
   */
  private String deliveryTrackIdGte;
  /**
   * 跟踪号 比较(lt)
   */
  private String deliveryTrackIdLt;
  /**
   * 跟踪号 比较(lte)
   */
  private String deliveryTrackIdLte;
  /**
   * 跟踪号 比较(contains)
   */
  private String deliveryTrackIdContains;
  /**
   * 跟踪号 比较(notcontains)
   */
  private String deliveryTrackIdNotcontains;
  /**
   * 跟踪号 比较(startswith)
   */
  private String deliveryTrackIdStartswith;
  /**
   * 跟踪号 比较(endswith)
   */
  private String deliveryTrackIdEndswith;
  /**
   * 跟踪号 比较(isnull)
   */
  private Boolean deliveryTrackIdIsnull;
  /**
   * 跟踪号 比较(isnotnull)
   */
  private Boolean deliveryTrackIdIsnotnull;

  /**
   * 跟踪号(精确搜索)
   */
  private List<String> deliveryTrackIdInList;

  /**
   * 合作伙伴订单号(模糊搜索)
   */
  private String deliveryPartnerOrderId;

  /**
   * 合作伙伴订单号 比较(eq)
   */
  private String deliveryPartnerOrderIdEq;
  /**
   * 合作伙伴订单号 比较(neq)
   */
  private String deliveryPartnerOrderIdNeq;
  /**
   * 合作伙伴订单号 比较(gt)
   */
  private String deliveryPartnerOrderIdGt;
  /**
   * 合作伙伴订单号 比较(gte)
   */
  private String deliveryPartnerOrderIdGte;
  /**
   * 合作伙伴订单号 比较(lt)
   */
  private String deliveryPartnerOrderIdLt;
  /**
   * 合作伙伴订单号 比较(lte)
   */
  private String deliveryPartnerOrderIdLte;
  /**
   * 合作伙伴订单号 比较(contains)
   */
  private String deliveryPartnerOrderIdContains;
  /**
   * 合作伙伴订单号 比较(notcontains)
   */
  private String deliveryPartnerOrderIdNotcontains;
  /**
   * 合作伙伴订单号 比较(startswith)
   */
  private String deliveryPartnerOrderIdStartswith;
  /**
   * 合作伙伴订单号 比较(endswith)
   */
  private String deliveryPartnerOrderIdEndswith;
  /**
   * 合作伙伴订单号 比较(isnull)
   */
  private Boolean deliveryPartnerOrderIdIsnull;
  /**
   * 合作伙伴订单号 比较(isnotnull)
   */
  private Boolean deliveryPartnerOrderIdIsnotnull;

  /**
   * 合作伙伴订单号(精确搜索)
   */
  private List<String> deliveryPartnerOrderIdInList;

  /**
   * 标发单号(模糊搜索)
   */
  private String deliveryIssuId;

  /**
   * 标发单号 比较(eq)
   */
  private String deliveryIssuIdEq;
  /**
   * 标发单号 比较(neq)
   */
  private String deliveryIssuIdNeq;
  /**
   * 标发单号 比较(gt)
   */
  private String deliveryIssuIdGt;
  /**
   * 标发单号 比较(gte)
   */
  private String deliveryIssuIdGte;
  /**
   * 标发单号 比较(lt)
   */
  private String deliveryIssuIdLt;
  /**
   * 标发单号 比较(lte)
   */
  private String deliveryIssuIdLte;
  /**
   * 标发单号 比较(contains)
   */
  private String deliveryIssuIdContains;
  /**
   * 标发单号 比较(notcontains)
   */
  private String deliveryIssuIdNotcontains;
  /**
   * 标发单号 比较(startswith)
   */
  private String deliveryIssuIdStartswith;
  /**
   * 标发单号 比较(endswith)
   */
  private String deliveryIssuIdEndswith;
  /**
   * 标发单号 比较(isnull)
   */
  private Boolean deliveryIssuIdIsnull;
  /**
   * 标发单号 比较(isnotnull)
   */
  private Boolean deliveryIssuIdIsnotnull;

  /**
   * 标发单号(精确搜索)
   */
  private List<String> deliveryIssuIdInList;

  /**
   * 发货方式
   */
  private String deliveryType;

  /**
   * 发货方式 比较(eq)
   */
  private String deliveryTypeEq;
  /**
   * 发货方式 比较(neq)
   */
  private String deliveryTypeNeq;
  /**
   * 发货方式 比较(gt)
   */
  private String deliveryTypeGt;
  /**
   * 发货方式 比较(gte)
   */
  private String deliveryTypeGte;
  /**
   * 发货方式 比较(lt)
   */
  private String deliveryTypeLt;
  /**
   * 发货方式 比较(lte)
   */
  private String deliveryTypeLte;
  /**
   * 发货方式 比较(contains)
   */
  private String deliveryTypeContains;
  /**
   * 发货方式 比较(notcontains)
   */
  private String deliveryTypeNotcontains;
  /**
   * 发货方式 比较(startswith)
   */
  private String deliveryTypeStartswith;
  /**
   * 发货方式 比较(endswith)
   */
  private String deliveryTypeEndswith;
  /**
   * 发货方式 比较(isnull)
   */
  private Boolean deliveryTypeIsnull;
  /**
   * 发货方式 比较(isnotnull)
   */
  private Boolean deliveryTypeIsnotnull;

  /**
   * 发货方式(精确搜索)
   */
  private List<String> deliveryTypeInList;

  /**
   * 最早物流下单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryTimeStart;

  /**
   * 最晚物流下单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryTimeEnd;

  /**
   * 物流下单时间 比较(eq)
   */
  private Date deliveryTimeEq;
  /**
   * 物流下单时间 比较(neq)
   */
  private Date deliveryTimeNeq;
  /**
   * 物流下单时间 比较(gt)
   */
  private Date deliveryTimeGt;
  /**
   * 物流下单时间 比较(gte)
   */
  private Date deliveryTimeGte;
  /**
   * 物流下单时间 比较(lt)
   */
  private Date deliveryTimeLt;
  /**
   * 物流下单时间 比较(lte)
   */
  private Date deliveryTimeLte;
  /**
   * 物流下单时间 比较(contains)
   */
  private Date deliveryTimeContains;
  /**
   * 物流下单时间 比较(notcontains)
   */
  private Date deliveryTimeNotcontains;
  /**
   * 物流下单时间 比较(startswith)
   */
  private Date deliveryTimeStartswith;
  /**
   * 物流下单时间 比较(endswith)
   */
  private Date deliveryTimeEndswith;
  /**
   * 物流下单时间 比较(isnull)
   */
  private Boolean deliveryTimeIsnull;
  /**
   * 物流下单时间 比较(isnotnull)
   */
  private Boolean deliveryTimeIsnotnull;

  /**
   * 最早标发时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date issuTimeStart;

  /**
   * 最晚标发时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date issuTimeEnd;

  /**
   * 标发时间 比较(eq)
   */
  private Date issuTimeEq;
  /**
   * 标发时间 比较(neq)
   */
  private Date issuTimeNeq;
  /**
   * 标发时间 比较(gt)
   */
  private Date issuTimeGt;
  /**
   * 标发时间 比较(gte)
   */
  private Date issuTimeGte;
  /**
   * 标发时间 比较(lt)
   */
  private Date issuTimeLt;
  /**
   * 标发时间 比较(lte)
   */
  private Date issuTimeLte;
  /**
   * 标发时间 比较(contains)
   */
  private Date issuTimeContains;
  /**
   * 标发时间 比较(notcontains)
   */
  private Date issuTimeNotcontains;
  /**
   * 标发时间 比较(startswith)
   */
  private Date issuTimeStartswith;
  /**
   * 标发时间 比较(endswith)
   */
  private Date issuTimeEndswith;
  /**
   * 标发时间 比较(isnull)
   */
  private Boolean issuTimeIsnull;
  /**
   * 标发时间 比较(isnotnull)
   */
  private Boolean issuTimeIsnotnull;

  /**
   * 收件税号类型
   */
  private String deliveryRecipientTaxType;

  /**
   * 收件税号类型 比较(eq)
   */
  private String deliveryRecipientTaxTypeEq;
  /**
   * 收件税号类型 比较(neq)
   */
  private String deliveryRecipientTaxTypeNeq;
  /**
   * 收件税号类型 比较(gt)
   */
  private String deliveryRecipientTaxTypeGt;
  /**
   * 收件税号类型 比较(gte)
   */
  private String deliveryRecipientTaxTypeGte;
  /**
   * 收件税号类型 比较(lt)
   */
  private String deliveryRecipientTaxTypeLt;
  /**
   * 收件税号类型 比较(lte)
   */
  private String deliveryRecipientTaxTypeLte;
  /**
   * 收件税号类型 比较(contains)
   */
  private String deliveryRecipientTaxTypeContains;
  /**
   * 收件税号类型 比较(notcontains)
   */
  private String deliveryRecipientTaxTypeNotcontains;
  /**
   * 收件税号类型 比较(startswith)
   */
  private String deliveryRecipientTaxTypeStartswith;
  /**
   * 收件税号类型 比较(endswith)
   */
  private String deliveryRecipientTaxTypeEndswith;
  /**
   * 收件税号类型 比较(isnull)
   */
  private Boolean deliveryRecipientTaxTypeIsnull;
  /**
   * 收件税号类型 比较(isnotnull)
   */
  private Boolean deliveryRecipientTaxTypeIsnotnull;

  /**
   * 收件税号类型(精确搜索)
   */
  private List<String> deliveryRecipientTaxTypeInList;

  /**
   * 收件人税号(模糊搜索)
   */
  private String deliveryRecipientTaxNo;

  /**
   * 收件人税号 比较(eq)
   */
  private String deliveryRecipientTaxNoEq;
  /**
   * 收件人税号 比较(neq)
   */
  private String deliveryRecipientTaxNoNeq;
  /**
   * 收件人税号 比较(gt)
   */
  private String deliveryRecipientTaxNoGt;
  /**
   * 收件人税号 比较(gte)
   */
  private String deliveryRecipientTaxNoGte;
  /**
   * 收件人税号 比较(lt)
   */
  private String deliveryRecipientTaxNoLt;
  /**
   * 收件人税号 比较(lte)
   */
  private String deliveryRecipientTaxNoLte;
  /**
   * 收件人税号 比较(contains)
   */
  private String deliveryRecipientTaxNoContains;
  /**
   * 收件人税号 比较(notcontains)
   */
  private String deliveryRecipientTaxNoNotcontains;
  /**
   * 收件人税号 比较(startswith)
   */
  private String deliveryRecipientTaxNoStartswith;
  /**
   * 收件人税号 比较(endswith)
   */
  private String deliveryRecipientTaxNoEndswith;
  /**
   * 收件人税号 比较(isnull)
   */
  private Boolean deliveryRecipientTaxNoIsnull;
  /**
   * 收件人税号 比较(isnotnull)
   */
  private Boolean deliveryRecipientTaxNoIsnotnull;

  /**
   * 收件人税号(精确搜索)
   */
  private List<String> deliveryRecipientTaxNoInList;

  /**
   * 收件人身份证号(模糊搜索)
   */
  private String deliveryRecipientIdentityNo;

  /**
   * 收件人身份证号 比较(eq)
   */
  private String deliveryRecipientIdentityNoEq;
  /**
   * 收件人身份证号 比较(neq)
   */
  private String deliveryRecipientIdentityNoNeq;
  /**
   * 收件人身份证号 比较(gt)
   */
  private String deliveryRecipientIdentityNoGt;
  /**
   * 收件人身份证号 比较(gte)
   */
  private String deliveryRecipientIdentityNoGte;
  /**
   * 收件人身份证号 比较(lt)
   */
  private String deliveryRecipientIdentityNoLt;
  /**
   * 收件人身份证号 比较(lte)
   */
  private String deliveryRecipientIdentityNoLte;
  /**
   * 收件人身份证号 比较(contains)
   */
  private String deliveryRecipientIdentityNoContains;
  /**
   * 收件人身份证号 比较(notcontains)
   */
  private String deliveryRecipientIdentityNoNotcontains;
  /**
   * 收件人身份证号 比较(startswith)
   */
  private String deliveryRecipientIdentityNoStartswith;
  /**
   * 收件人身份证号 比较(endswith)
   */
  private String deliveryRecipientIdentityNoEndswith;
  /**
   * 收件人身份证号 比较(isnull)
   */
  private Boolean deliveryRecipientIdentityNoIsnull;
  /**
   * 收件人身份证号 比较(isnotnull)
   */
  private Boolean deliveryRecipientIdentityNoIsnotnull;

  /**
   * 收件人身份证号(精确搜索)
   */
  private List<String> deliveryRecipientIdentityNoInList;

  /**
   * 发件税号类型
   */
  private String deliverySenderTaxNoType;

  /**
   * 发件税号类型 比较(eq)
   */
  private String deliverySenderTaxNoTypeEq;
  /**
   * 发件税号类型 比较(neq)
   */
  private String deliverySenderTaxNoTypeNeq;
  /**
   * 发件税号类型 比较(gt)
   */
  private String deliverySenderTaxNoTypeGt;
  /**
   * 发件税号类型 比较(gte)
   */
  private String deliverySenderTaxNoTypeGte;
  /**
   * 发件税号类型 比较(lt)
   */
  private String deliverySenderTaxNoTypeLt;
  /**
   * 发件税号类型 比较(lte)
   */
  private String deliverySenderTaxNoTypeLte;
  /**
   * 发件税号类型 比较(contains)
   */
  private String deliverySenderTaxNoTypeContains;
  /**
   * 发件税号类型 比较(notcontains)
   */
  private String deliverySenderTaxNoTypeNotcontains;
  /**
   * 发件税号类型 比较(startswith)
   */
  private String deliverySenderTaxNoTypeStartswith;
  /**
   * 发件税号类型 比较(endswith)
   */
  private String deliverySenderTaxNoTypeEndswith;
  /**
   * 发件税号类型 比较(isnull)
   */
  private Boolean deliverySenderTaxNoTypeIsnull;
  /**
   * 发件税号类型 比较(isnotnull)
   */
  private Boolean deliverySenderTaxNoTypeIsnotnull;

  /**
   * 发件税号类型(精确搜索)
   */
  private List<String> deliverySenderTaxNoTypeInList;

  /**
   * 发件人税号(模糊搜索)
   */
  private String deliverySenderTaxNo;

  /**
   * 发件人税号 比较(eq)
   */
  private String deliverySenderTaxNoEq;
  /**
   * 发件人税号 比较(neq)
   */
  private String deliverySenderTaxNoNeq;
  /**
   * 发件人税号 比较(gt)
   */
  private String deliverySenderTaxNoGt;
  /**
   * 发件人税号 比较(gte)
   */
  private String deliverySenderTaxNoGte;
  /**
   * 发件人税号 比较(lt)
   */
  private String deliverySenderTaxNoLt;
  /**
   * 发件人税号 比较(lte)
   */
  private String deliverySenderTaxNoLte;
  /**
   * 发件人税号 比较(contains)
   */
  private String deliverySenderTaxNoContains;
  /**
   * 发件人税号 比较(notcontains)
   */
  private String deliverySenderTaxNoNotcontains;
  /**
   * 发件人税号 比较(startswith)
   */
  private String deliverySenderTaxNoStartswith;
  /**
   * 发件人税号 比较(endswith)
   */
  private String deliverySenderTaxNoEndswith;
  /**
   * 发件人税号 比较(isnull)
   */
  private Boolean deliverySenderTaxNoIsnull;
  /**
   * 发件人税号 比较(isnotnull)
   */
  private Boolean deliverySenderTaxNoIsnotnull;

  /**
   * 发件人税号(精确搜索)
   */
  private List<String> deliverySenderTaxNoInList;

  /**
   * COD订单
   */
  private String deliveryCodeOrder;

  /**
   * COD订单 比较(eq)
   */
  private String deliveryCodeOrderEq;
  /**
   * COD订单 比较(neq)
   */
  private String deliveryCodeOrderNeq;
  /**
   * COD订单 比较(gt)
   */
  private String deliveryCodeOrderGt;
  /**
   * COD订单 比较(gte)
   */
  private String deliveryCodeOrderGte;
  /**
   * COD订单 比较(lt)
   */
  private String deliveryCodeOrderLt;
  /**
   * COD订单 比较(lte)
   */
  private String deliveryCodeOrderLte;
  /**
   * COD订单 比较(contains)
   */
  private String deliveryCodeOrderContains;
  /**
   * COD订单 比较(notcontains)
   */
  private String deliveryCodeOrderNotcontains;
  /**
   * COD订单 比较(startswith)
   */
  private String deliveryCodeOrderStartswith;
  /**
   * COD订单 比较(endswith)
   */
  private String deliveryCodeOrderEndswith;
  /**
   * COD订单 比较(isnull)
   */
  private Boolean deliveryCodeOrderIsnull;
  /**
   * COD订单 比较(isnotnull)
   */
  private Boolean deliveryCodeOrderIsnotnull;

  /**
   * COD订单(精确搜索)
   */
  private List<String> deliveryCodeOrderInList;

  /**
   * 预估运费
   */
  private java.math.BigDecimal deliveryThinkFreight;

  /**
   * 最小预估运费
   */
  private java.math.BigDecimal deliveryThinkFreightMin;

  /**
   * 最大预估运费
   */
  private java.math.BigDecimal deliveryThinkFreightMax;

  /**
   * 预估运费 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkFreightEq;
  /**
   * 预估运费 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkFreightNeq;
  /**
   * 预估运费 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkFreightGt;
  /**
   * 预估运费 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkFreightGte;
  /**
   * 预估运费 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkFreightLt;
  /**
   * 预估运费 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkFreightLte;
  /**
   * 预估运费 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkFreightContains;
  /**
   * 预估运费 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkFreightNotcontains;
  /**
   * 预估运费 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkFreightStartswith;
  /**
   * 预估运费 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkFreightEndswith;
  /**
   * 预估运费 比较(isnull)
   */
  private Boolean deliveryThinkFreightIsnull;
  /**
   * 预估运费 比较(isnotnull)
   */
  private Boolean deliveryThinkFreightIsnotnull;

  /**
   * 估算重量单位
   */
  private String deliveryThinkWeightUnit;

  /**
   * 估算重量单位 比较(eq)
   */
  private String deliveryThinkWeightUnitEq;
  /**
   * 估算重量单位 比较(neq)
   */
  private String deliveryThinkWeightUnitNeq;
  /**
   * 估算重量单位 比较(gt)
   */
  private String deliveryThinkWeightUnitGt;
  /**
   * 估算重量单位 比较(gte)
   */
  private String deliveryThinkWeightUnitGte;
  /**
   * 估算重量单位 比较(lt)
   */
  private String deliveryThinkWeightUnitLt;
  /**
   * 估算重量单位 比较(lte)
   */
  private String deliveryThinkWeightUnitLte;
  /**
   * 估算重量单位 比较(contains)
   */
  private String deliveryThinkWeightUnitContains;
  /**
   * 估算重量单位 比较(notcontains)
   */
  private String deliveryThinkWeightUnitNotcontains;
  /**
   * 估算重量单位 比较(startswith)
   */
  private String deliveryThinkWeightUnitStartswith;
  /**
   * 估算重量单位 比较(endswith)
   */
  private String deliveryThinkWeightUnitEndswith;
  /**
   * 估算重量单位 比较(isnull)
   */
  private Boolean deliveryThinkWeightUnitIsnull;
  /**
   * 估算重量单位 比较(isnotnull)
   */
  private Boolean deliveryThinkWeightUnitIsnotnull;

  /**
   * 估算重量单位(精确搜索)
   */
  private List<String> deliveryThinkWeightUnitInList;

  /**
   * 估算重量
   */
  private java.math.BigDecimal deliveryThinkWeight;

  /**
   * 最小估算重量
   */
  private java.math.BigDecimal deliveryThinkWeightMin;

  /**
   * 最大估算重量
   */
  private java.math.BigDecimal deliveryThinkWeightMax;

  /**
   * 估算重量 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean deliveryThinkWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean deliveryThinkWeightIsnotnull;

  /**
   * 估算尺寸单位
   */
  private String deliveryThinkSizeUnit;

  /**
   * 估算尺寸单位 比较(eq)
   */
  private String deliveryThinkSizeUnitEq;
  /**
   * 估算尺寸单位 比较(neq)
   */
  private String deliveryThinkSizeUnitNeq;
  /**
   * 估算尺寸单位 比较(gt)
   */
  private String deliveryThinkSizeUnitGt;
  /**
   * 估算尺寸单位 比较(gte)
   */
  private String deliveryThinkSizeUnitGte;
  /**
   * 估算尺寸单位 比较(lt)
   */
  private String deliveryThinkSizeUnitLt;
  /**
   * 估算尺寸单位 比较(lte)
   */
  private String deliveryThinkSizeUnitLte;
  /**
   * 估算尺寸单位 比较(contains)
   */
  private String deliveryThinkSizeUnitContains;
  /**
   * 估算尺寸单位 比较(notcontains)
   */
  private String deliveryThinkSizeUnitNotcontains;
  /**
   * 估算尺寸单位 比较(startswith)
   */
  private String deliveryThinkSizeUnitStartswith;
  /**
   * 估算尺寸单位 比较(endswith)
   */
  private String deliveryThinkSizeUnitEndswith;
  /**
   * 估算尺寸单位 比较(isnull)
   */
  private Boolean deliveryThinkSizeUnitIsnull;
  /**
   * 估算尺寸单位 比较(isnotnull)
   */
  private Boolean deliveryThinkSizeUnitIsnotnull;

  /**
   * 估算尺寸单位(精确搜索)
   */
  private List<String> deliveryThinkSizeUnitInList;

  /**
   * 估算尺寸长
   */
  private java.math.BigDecimal deliveryThinkSizeLength;

  /**
   * 最小估算尺寸长
   */
  private java.math.BigDecimal deliveryThinkSizeLengthMin;

  /**
   * 最大估算尺寸长
   */
  private java.math.BigDecimal deliveryThinkSizeLengthMax;

  /**
   * 估算尺寸长 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthEq;
  /**
   * 估算尺寸长 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthNeq;
  /**
   * 估算尺寸长 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthGt;
  /**
   * 估算尺寸长 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthGte;
  /**
   * 估算尺寸长 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthLt;
  /**
   * 估算尺寸长 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthLte;
  /**
   * 估算尺寸长 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthContains;
  /**
   * 估算尺寸长 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthNotcontains;
  /**
   * 估算尺寸长 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthStartswith;
  /**
   * 估算尺寸长 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkSizeLengthEndswith;
  /**
   * 估算尺寸长 比较(isnull)
   */
  private Boolean deliveryThinkSizeLengthIsnull;
  /**
   * 估算尺寸长 比较(isnotnull)
   */
  private Boolean deliveryThinkSizeLengthIsnotnull;

  /**
   * 估算尺寸宽
   */
  private java.math.BigDecimal deliveryThinkSizeWidth;

  /**
   * 最小估算尺寸宽
   */
  private java.math.BigDecimal deliveryThinkSizeWidthMin;

  /**
   * 最大估算尺寸宽
   */
  private java.math.BigDecimal deliveryThinkSizeWidthMax;

  /**
   * 估算尺寸宽 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthEq;
  /**
   * 估算尺寸宽 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthNeq;
  /**
   * 估算尺寸宽 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthGt;
  /**
   * 估算尺寸宽 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthGte;
  /**
   * 估算尺寸宽 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthLt;
  /**
   * 估算尺寸宽 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthLte;
  /**
   * 估算尺寸宽 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthContains;
  /**
   * 估算尺寸宽 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthNotcontains;
  /**
   * 估算尺寸宽 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthStartswith;
  /**
   * 估算尺寸宽 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkSizeWidthEndswith;
  /**
   * 估算尺寸宽 比较(isnull)
   */
  private Boolean deliveryThinkSizeWidthIsnull;
  /**
   * 估算尺寸宽 比较(isnotnull)
   */
  private Boolean deliveryThinkSizeWidthIsnotnull;

  /**
   * 估算尺寸高
   */
  private java.math.BigDecimal deliveryThinkSizeHeight;

  /**
   * 最小估算尺寸高
   */
  private java.math.BigDecimal deliveryThinkSizeHeightMin;

  /**
   * 最大估算尺寸高
   */
  private java.math.BigDecimal deliveryThinkSizeHeightMax;

  /**
   * 估算尺寸高 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightEq;
  /**
   * 估算尺寸高 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightNeq;
  /**
   * 估算尺寸高 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightGt;
  /**
   * 估算尺寸高 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightGte;
  /**
   * 估算尺寸高 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightLt;
  /**
   * 估算尺寸高 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightLte;
  /**
   * 估算尺寸高 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightContains;
  /**
   * 估算尺寸高 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightNotcontains;
  /**
   * 估算尺寸高 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightStartswith;
  /**
   * 估算尺寸高 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkSizeHeightEndswith;
  /**
   * 估算尺寸高 比较(isnull)
   */
  private Boolean deliveryThinkSizeHeightIsnull;
  /**
   * 估算尺寸高 比较(isnotnull)
   */
  private Boolean deliveryThinkSizeHeightIsnotnull;

  /**
   * 预估包裹体积单位
   */
  private String deliveryThinkVolumeUnit;

  /**
   * 预估包裹体积单位 比较(eq)
   */
  private String deliveryThinkVolumeUnitEq;
  /**
   * 预估包裹体积单位 比较(neq)
   */
  private String deliveryThinkVolumeUnitNeq;
  /**
   * 预估包裹体积单位 比较(gt)
   */
  private String deliveryThinkVolumeUnitGt;
  /**
   * 预估包裹体积单位 比较(gte)
   */
  private String deliveryThinkVolumeUnitGte;
  /**
   * 预估包裹体积单位 比较(lt)
   */
  private String deliveryThinkVolumeUnitLt;
  /**
   * 预估包裹体积单位 比较(lte)
   */
  private String deliveryThinkVolumeUnitLte;
  /**
   * 预估包裹体积单位 比较(contains)
   */
  private String deliveryThinkVolumeUnitContains;
  /**
   * 预估包裹体积单位 比较(notcontains)
   */
  private String deliveryThinkVolumeUnitNotcontains;
  /**
   * 预估包裹体积单位 比较(startswith)
   */
  private String deliveryThinkVolumeUnitStartswith;
  /**
   * 预估包裹体积单位 比较(endswith)
   */
  private String deliveryThinkVolumeUnitEndswith;
  /**
   * 预估包裹体积单位 比较(isnull)
   */
  private Boolean deliveryThinkVolumeUnitIsnull;
  /**
   * 预估包裹体积单位 比较(isnotnull)
   */
  private Boolean deliveryThinkVolumeUnitIsnotnull;

  /**
   * 预估包裹体积单位(精确搜索)
   */
  private List<String> deliveryThinkVolumeUnitInList;

  /**
   * 预估包裹体积
   */
  private java.math.BigDecimal deliveryThinkVolume;

  /**
   * 最小预估包裹体积
   */
  private java.math.BigDecimal deliveryThinkVolumeMin;

  /**
   * 最大预估包裹体积
   */
  private java.math.BigDecimal deliveryThinkVolumeMax;

  /**
   * 预估包裹体积 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkVolumeEq;
  /**
   * 预估包裹体积 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkVolumeNeq;
  /**
   * 预估包裹体积 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkVolumeGt;
  /**
   * 预估包裹体积 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkVolumeGte;
  /**
   * 预估包裹体积 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkVolumeLt;
  /**
   * 预估包裹体积 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkVolumeLte;
  /**
   * 预估包裹体积 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkVolumeContains;
  /**
   * 预估包裹体积 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkVolumeNotcontains;
  /**
   * 预估包裹体积 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkVolumeStartswith;
  /**
   * 预估包裹体积 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkVolumeEndswith;
  /**
   * 预估包裹体积 比较(isnull)
   */
  private Boolean deliveryThinkVolumeIsnull;
  /**
   * 预估包裹体积 比较(isnotnull)
   */
  private Boolean deliveryThinkVolumeIsnotnull;

  /**
   * 估算计费重量单位
   */
  private String deliveryThinkFeeWeightUnit;

  /**
   * 估算计费重量单位 比较(eq)
   */
  private String deliveryThinkFeeWeightUnitEq;
  /**
   * 估算计费重量单位 比较(neq)
   */
  private String deliveryThinkFeeWeightUnitNeq;
  /**
   * 估算计费重量单位 比较(gt)
   */
  private String deliveryThinkFeeWeightUnitGt;
  /**
   * 估算计费重量单位 比较(gte)
   */
  private String deliveryThinkFeeWeightUnitGte;
  /**
   * 估算计费重量单位 比较(lt)
   */
  private String deliveryThinkFeeWeightUnitLt;
  /**
   * 估算计费重量单位 比较(lte)
   */
  private String deliveryThinkFeeWeightUnitLte;
  /**
   * 估算计费重量单位 比较(contains)
   */
  private String deliveryThinkFeeWeightUnitContains;
  /**
   * 估算计费重量单位 比较(notcontains)
   */
  private String deliveryThinkFeeWeightUnitNotcontains;
  /**
   * 估算计费重量单位 比较(startswith)
   */
  private String deliveryThinkFeeWeightUnitStartswith;
  /**
   * 估算计费重量单位 比较(endswith)
   */
  private String deliveryThinkFeeWeightUnitEndswith;
  /**
   * 估算计费重量单位 比较(isnull)
   */
  private Boolean deliveryThinkFeeWeightUnitIsnull;
  /**
   * 估算计费重量单位 比较(isnotnull)
   */
  private Boolean deliveryThinkFeeWeightUnitIsnotnull;

  /**
   * 估算计费重量单位(精确搜索)
   */
  private List<String> deliveryThinkFeeWeightUnitInList;

  /**
   * 估算计费重量
   */
  private java.math.BigDecimal deliveryThinkFeeWeight;

  /**
   * 最小估算计费重量
   */
  private java.math.BigDecimal deliveryThinkFeeWeightMin;

  /**
   * 最大估算计费重量
   */
  private java.math.BigDecimal deliveryThinkFeeWeightMax;

  /**
   * 估算计费重量 比较(eq)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightEq;
  /**
   * 估算计费重量 比较(neq)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightNeq;
  /**
   * 估算计费重量 比较(gt)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightGt;
  /**
   * 估算计费重量 比较(gte)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightGte;
  /**
   * 估算计费重量 比较(lt)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightLt;
  /**
   * 估算计费重量 比较(lte)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightLte;
  /**
   * 估算计费重量 比较(contains)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightContains;
  /**
   * 估算计费重量 比较(notcontains)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightNotcontains;
  /**
   * 估算计费重量 比较(startswith)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightStartswith;
  /**
   * 估算计费重量 比较(endswith)
   */
  private java.math.BigDecimal deliveryThinkFeeWeightEndswith;
  /**
   * 估算计费重量 比较(isnull)
   */
  private Boolean deliveryThinkFeeWeightIsnull;
  /**
   * 估算计费重量 比较(isnotnull)
   */
  private Boolean deliveryThinkFeeWeightIsnotnull;

  /**
   * 包裹实重单位
   */
  private String deliveryRealWeightUnit;

  /**
   * 包裹实重单位 比较(eq)
   */
  private String deliveryRealWeightUnitEq;
  /**
   * 包裹实重单位 比较(neq)
   */
  private String deliveryRealWeightUnitNeq;
  /**
   * 包裹实重单位 比较(gt)
   */
  private String deliveryRealWeightUnitGt;
  /**
   * 包裹实重单位 比较(gte)
   */
  private String deliveryRealWeightUnitGte;
  /**
   * 包裹实重单位 比较(lt)
   */
  private String deliveryRealWeightUnitLt;
  /**
   * 包裹实重单位 比较(lte)
   */
  private String deliveryRealWeightUnitLte;
  /**
   * 包裹实重单位 比较(contains)
   */
  private String deliveryRealWeightUnitContains;
  /**
   * 包裹实重单位 比较(notcontains)
   */
  private String deliveryRealWeightUnitNotcontains;
  /**
   * 包裹实重单位 比较(startswith)
   */
  private String deliveryRealWeightUnitStartswith;
  /**
   * 包裹实重单位 比较(endswith)
   */
  private String deliveryRealWeightUnitEndswith;
  /**
   * 包裹实重单位 比较(isnull)
   */
  private Boolean deliveryRealWeightUnitIsnull;
  /**
   * 包裹实重单位 比较(isnotnull)
   */
  private Boolean deliveryRealWeightUnitIsnotnull;

  /**
   * 包裹实重单位(精确搜索)
   */
  private List<String> deliveryRealWeightUnitInList;

  /**
   * 包裹实重
   */
  private java.math.BigDecimal deliveryRealWeight;

  /**
   * 最小包裹实重
   */
  private java.math.BigDecimal deliveryRealWeightMin;

  /**
   * 最大包裹实重
   */
  private java.math.BigDecimal deliveryRealWeightMax;

  /**
   * 包裹实重 比较(eq)
   */
  private java.math.BigDecimal deliveryRealWeightEq;
  /**
   * 包裹实重 比较(neq)
   */
  private java.math.BigDecimal deliveryRealWeightNeq;
  /**
   * 包裹实重 比较(gt)
   */
  private java.math.BigDecimal deliveryRealWeightGt;
  /**
   * 包裹实重 比较(gte)
   */
  private java.math.BigDecimal deliveryRealWeightGte;
  /**
   * 包裹实重 比较(lt)
   */
  private java.math.BigDecimal deliveryRealWeightLt;
  /**
   * 包裹实重 比较(lte)
   */
  private java.math.BigDecimal deliveryRealWeightLte;
  /**
   * 包裹实重 比较(contains)
   */
  private java.math.BigDecimal deliveryRealWeightContains;
  /**
   * 包裹实重 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealWeightNotcontains;
  /**
   * 包裹实重 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealWeightStartswith;
  /**
   * 包裹实重 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealWeightEndswith;
  /**
   * 包裹实重 比较(isnull)
   */
  private Boolean deliveryRealWeightIsnull;
  /**
   * 包裹实重 比较(isnotnull)
   */
  private Boolean deliveryRealWeightIsnotnull;

  /**
   * 包裹尺寸单位
   */
  private String deliveryRealSizeUnit;

  /**
   * 包裹尺寸单位 比较(eq)
   */
  private String deliveryRealSizeUnitEq;
  /**
   * 包裹尺寸单位 比较(neq)
   */
  private String deliveryRealSizeUnitNeq;
  /**
   * 包裹尺寸单位 比较(gt)
   */
  private String deliveryRealSizeUnitGt;
  /**
   * 包裹尺寸单位 比较(gte)
   */
  private String deliveryRealSizeUnitGte;
  /**
   * 包裹尺寸单位 比较(lt)
   */
  private String deliveryRealSizeUnitLt;
  /**
   * 包裹尺寸单位 比较(lte)
   */
  private String deliveryRealSizeUnitLte;
  /**
   * 包裹尺寸单位 比较(contains)
   */
  private String deliveryRealSizeUnitContains;
  /**
   * 包裹尺寸单位 比较(notcontains)
   */
  private String deliveryRealSizeUnitNotcontains;
  /**
   * 包裹尺寸单位 比较(startswith)
   */
  private String deliveryRealSizeUnitStartswith;
  /**
   * 包裹尺寸单位 比较(endswith)
   */
  private String deliveryRealSizeUnitEndswith;
  /**
   * 包裹尺寸单位 比较(isnull)
   */
  private Boolean deliveryRealSizeUnitIsnull;
  /**
   * 包裹尺寸单位 比较(isnotnull)
   */
  private Boolean deliveryRealSizeUnitIsnotnull;

  /**
   * 包裹尺寸单位(精确搜索)
   */
  private List<String> deliveryRealSizeUnitInList;

  /**
   * 包裹长
   */
  private java.math.BigDecimal deliveryRealSizeLength;

  /**
   * 最小包裹长
   */
  private java.math.BigDecimal deliveryRealSizeLengthMin;

  /**
   * 最大包裹长
   */
  private java.math.BigDecimal deliveryRealSizeLengthMax;

  /**
   * 包裹长 比较(eq)
   */
  private java.math.BigDecimal deliveryRealSizeLengthEq;
  /**
   * 包裹长 比较(neq)
   */
  private java.math.BigDecimal deliveryRealSizeLengthNeq;
  /**
   * 包裹长 比较(gt)
   */
  private java.math.BigDecimal deliveryRealSizeLengthGt;
  /**
   * 包裹长 比较(gte)
   */
  private java.math.BigDecimal deliveryRealSizeLengthGte;
  /**
   * 包裹长 比较(lt)
   */
  private java.math.BigDecimal deliveryRealSizeLengthLt;
  /**
   * 包裹长 比较(lte)
   */
  private java.math.BigDecimal deliveryRealSizeLengthLte;
  /**
   * 包裹长 比较(contains)
   */
  private java.math.BigDecimal deliveryRealSizeLengthContains;
  /**
   * 包裹长 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealSizeLengthNotcontains;
  /**
   * 包裹长 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealSizeLengthStartswith;
  /**
   * 包裹长 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealSizeLengthEndswith;
  /**
   * 包裹长 比较(isnull)
   */
  private Boolean deliveryRealSizeLengthIsnull;
  /**
   * 包裹长 比较(isnotnull)
   */
  private Boolean deliveryRealSizeLengthIsnotnull;

  /**
   * 包裹宽
   */
  private java.math.BigDecimal deliveryRealSizeWidth;

  /**
   * 最小包裹宽
   */
  private java.math.BigDecimal deliveryRealSizeWidthMin;

  /**
   * 最大包裹宽
   */
  private java.math.BigDecimal deliveryRealSizeWidthMax;

  /**
   * 包裹宽 比较(eq)
   */
  private java.math.BigDecimal deliveryRealSizeWidthEq;
  /**
   * 包裹宽 比较(neq)
   */
  private java.math.BigDecimal deliveryRealSizeWidthNeq;
  /**
   * 包裹宽 比较(gt)
   */
  private java.math.BigDecimal deliveryRealSizeWidthGt;
  /**
   * 包裹宽 比较(gte)
   */
  private java.math.BigDecimal deliveryRealSizeWidthGte;
  /**
   * 包裹宽 比较(lt)
   */
  private java.math.BigDecimal deliveryRealSizeWidthLt;
  /**
   * 包裹宽 比较(lte)
   */
  private java.math.BigDecimal deliveryRealSizeWidthLte;
  /**
   * 包裹宽 比较(contains)
   */
  private java.math.BigDecimal deliveryRealSizeWidthContains;
  /**
   * 包裹宽 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealSizeWidthNotcontains;
  /**
   * 包裹宽 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealSizeWidthStartswith;
  /**
   * 包裹宽 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealSizeWidthEndswith;
  /**
   * 包裹宽 比较(isnull)
   */
  private Boolean deliveryRealSizeWidthIsnull;
  /**
   * 包裹宽 比较(isnotnull)
   */
  private Boolean deliveryRealSizeWidthIsnotnull;

  /**
   * 包裹高
   */
  private java.math.BigDecimal deliveryRealSizeHeight;

  /**
   * 最小包裹高
   */
  private java.math.BigDecimal deliveryRealSizeHeightMin;

  /**
   * 最大包裹高
   */
  private java.math.BigDecimal deliveryRealSizeHeightMax;

  /**
   * 包裹高 比较(eq)
   */
  private java.math.BigDecimal deliveryRealSizeHeightEq;
  /**
   * 包裹高 比较(neq)
   */
  private java.math.BigDecimal deliveryRealSizeHeightNeq;
  /**
   * 包裹高 比较(gt)
   */
  private java.math.BigDecimal deliveryRealSizeHeightGt;
  /**
   * 包裹高 比较(gte)
   */
  private java.math.BigDecimal deliveryRealSizeHeightGte;
  /**
   * 包裹高 比较(lt)
   */
  private java.math.BigDecimal deliveryRealSizeHeightLt;
  /**
   * 包裹高 比较(lte)
   */
  private java.math.BigDecimal deliveryRealSizeHeightLte;
  /**
   * 包裹高 比较(contains)
   */
  private java.math.BigDecimal deliveryRealSizeHeightContains;
  /**
   * 包裹高 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealSizeHeightNotcontains;
  /**
   * 包裹高 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealSizeHeightStartswith;
  /**
   * 包裹高 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealSizeHeightEndswith;
  /**
   * 包裹高 比较(isnull)
   */
  private Boolean deliveryRealSizeHeightIsnull;
  /**
   * 包裹高 比较(isnotnull)
   */
  private Boolean deliveryRealSizeHeightIsnotnull;

  /**
   * 包裹体积单位
   */
  private String deliveryRealVolumeUnit;

  /**
   * 包裹体积单位 比较(eq)
   */
  private String deliveryRealVolumeUnitEq;
  /**
   * 包裹体积单位 比较(neq)
   */
  private String deliveryRealVolumeUnitNeq;
  /**
   * 包裹体积单位 比较(gt)
   */
  private String deliveryRealVolumeUnitGt;
  /**
   * 包裹体积单位 比较(gte)
   */
  private String deliveryRealVolumeUnitGte;
  /**
   * 包裹体积单位 比较(lt)
   */
  private String deliveryRealVolumeUnitLt;
  /**
   * 包裹体积单位 比较(lte)
   */
  private String deliveryRealVolumeUnitLte;
  /**
   * 包裹体积单位 比较(contains)
   */
  private String deliveryRealVolumeUnitContains;
  /**
   * 包裹体积单位 比较(notcontains)
   */
  private String deliveryRealVolumeUnitNotcontains;
  /**
   * 包裹体积单位 比较(startswith)
   */
  private String deliveryRealVolumeUnitStartswith;
  /**
   * 包裹体积单位 比较(endswith)
   */
  private String deliveryRealVolumeUnitEndswith;
  /**
   * 包裹体积单位 比较(isnull)
   */
  private Boolean deliveryRealVolumeUnitIsnull;
  /**
   * 包裹体积单位 比较(isnotnull)
   */
  private Boolean deliveryRealVolumeUnitIsnotnull;

  /**
   * 包裹体积单位(精确搜索)
   */
  private List<String> deliveryRealVolumeUnitInList;

  /**
   * 包裹体积
   */
  private java.math.BigDecimal deliveryRealVolume;

  /**
   * 最小包裹体积
   */
  private java.math.BigDecimal deliveryRealVolumeMin;

  /**
   * 最大包裹体积
   */
  private java.math.BigDecimal deliveryRealVolumeMax;

  /**
   * 包裹体积 比较(eq)
   */
  private java.math.BigDecimal deliveryRealVolumeEq;
  /**
   * 包裹体积 比较(neq)
   */
  private java.math.BigDecimal deliveryRealVolumeNeq;
  /**
   * 包裹体积 比较(gt)
   */
  private java.math.BigDecimal deliveryRealVolumeGt;
  /**
   * 包裹体积 比较(gte)
   */
  private java.math.BigDecimal deliveryRealVolumeGte;
  /**
   * 包裹体积 比较(lt)
   */
  private java.math.BigDecimal deliveryRealVolumeLt;
  /**
   * 包裹体积 比较(lte)
   */
  private java.math.BigDecimal deliveryRealVolumeLte;
  /**
   * 包裹体积 比较(contains)
   */
  private java.math.BigDecimal deliveryRealVolumeContains;
  /**
   * 包裹体积 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealVolumeNotcontains;
  /**
   * 包裹体积 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealVolumeStartswith;
  /**
   * 包裹体积 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealVolumeEndswith;
  /**
   * 包裹体积 比较(isnull)
   */
  private Boolean deliveryRealVolumeIsnull;
  /**
   * 包裹体积 比较(isnotnull)
   */
  private Boolean deliveryRealVolumeIsnotnull;

  /**
   * 实际计费重量单位
   */
  private String deliveryRealFeeWeightUnit;

  /**
   * 实际计费重量单位 比较(eq)
   */
  private String deliveryRealFeeWeightUnitEq;
  /**
   * 实际计费重量单位 比较(neq)
   */
  private String deliveryRealFeeWeightUnitNeq;
  /**
   * 实际计费重量单位 比较(gt)
   */
  private String deliveryRealFeeWeightUnitGt;
  /**
   * 实际计费重量单位 比较(gte)
   */
  private String deliveryRealFeeWeightUnitGte;
  /**
   * 实际计费重量单位 比较(lt)
   */
  private String deliveryRealFeeWeightUnitLt;
  /**
   * 实际计费重量单位 比较(lte)
   */
  private String deliveryRealFeeWeightUnitLte;
  /**
   * 实际计费重量单位 比较(contains)
   */
  private String deliveryRealFeeWeightUnitContains;
  /**
   * 实际计费重量单位 比较(notcontains)
   */
  private String deliveryRealFeeWeightUnitNotcontains;
  /**
   * 实际计费重量单位 比较(startswith)
   */
  private String deliveryRealFeeWeightUnitStartswith;
  /**
   * 实际计费重量单位 比较(endswith)
   */
  private String deliveryRealFeeWeightUnitEndswith;
  /**
   * 实际计费重量单位 比较(isnull)
   */
  private Boolean deliveryRealFeeWeightUnitIsnull;
  /**
   * 实际计费重量单位 比较(isnotnull)
   */
  private Boolean deliveryRealFeeWeightUnitIsnotnull;

  /**
   * 实际计费重量单位(精确搜索)
   */
  private List<String> deliveryRealFeeWeightUnitInList;

  /**
   * 实际计费重量
   */
  private java.math.BigDecimal deliveryRealFeeWeight;

  /**
   * 最小实际计费重量
   */
  private java.math.BigDecimal deliveryRealFeeWeightMin;

  /**
   * 最大实际计费重量
   */
  private java.math.BigDecimal deliveryRealFeeWeightMax;

  /**
   * 实际计费重量 比较(eq)
   */
  private java.math.BigDecimal deliveryRealFeeWeightEq;
  /**
   * 实际计费重量 比较(neq)
   */
  private java.math.BigDecimal deliveryRealFeeWeightNeq;
  /**
   * 实际计费重量 比较(gt)
   */
  private java.math.BigDecimal deliveryRealFeeWeightGt;
  /**
   * 实际计费重量 比较(gte)
   */
  private java.math.BigDecimal deliveryRealFeeWeightGte;
  /**
   * 实际计费重量 比较(lt)
   */
  private java.math.BigDecimal deliveryRealFeeWeightLt;
  /**
   * 实际计费重量 比较(lte)
   */
  private java.math.BigDecimal deliveryRealFeeWeightLte;
  /**
   * 实际计费重量 比较(contains)
   */
  private java.math.BigDecimal deliveryRealFeeWeightContains;
  /**
   * 实际计费重量 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealFeeWeightNotcontains;
  /**
   * 实际计费重量 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealFeeWeightStartswith;
  /**
   * 实际计费重量 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealFeeWeightEndswith;
  /**
   * 实际计费重量 比较(isnull)
   */
  private Boolean deliveryRealFeeWeightIsnull;
  /**
   * 实际计费重量 比较(isnotnull)
   */
  private Boolean deliveryRealFeeWeightIsnotnull;

  /**
   * 包裹数量
   */
  private Integer deliveryRealQuantity;

  /**
   * 最小包裹数量
   */
  private Integer deliveryRealQuantityMin;

  /**
   * 最大包裹数量
   */
  private Integer deliveryRealQuantityMax;

  /**
   * 包裹数量 比较(eq)
   */
  private Integer deliveryRealQuantityEq;
  /**
   * 包裹数量 比较(neq)
   */
  private Integer deliveryRealQuantityNeq;
  /**
   * 包裹数量 比较(gt)
   */
  private Integer deliveryRealQuantityGt;
  /**
   * 包裹数量 比较(gte)
   */
  private Integer deliveryRealQuantityGte;
  /**
   * 包裹数量 比较(lt)
   */
  private Integer deliveryRealQuantityLt;
  /**
   * 包裹数量 比较(lte)
   */
  private Integer deliveryRealQuantityLte;
  /**
   * 包裹数量 比较(contains)
   */
  private Integer deliveryRealQuantityContains;
  /**
   * 包裹数量 比较(notcontains)
   */
  private Integer deliveryRealQuantityNotcontains;
  /**
   * 包裹数量 比较(startswith)
   */
  private Integer deliveryRealQuantityStartswith;
  /**
   * 包裹数量 比较(endswith)
   */
  private Integer deliveryRealQuantityEndswith;
  /**
   * 包裹数量 比较(isnull)
   */
  private Boolean deliveryRealQuantityIsnull;
  /**
   * 包裹数量 比较(isnotnull)
   */
  private Boolean deliveryRealQuantityIsnotnull;

  /**
   * 物流运费币种
   */
  private String deliveryRealCurrencyCode;

  /**
   * 物流运费币种 比较(eq)
   */
  private String deliveryRealCurrencyCodeEq;
  /**
   * 物流运费币种 比较(neq)
   */
  private String deliveryRealCurrencyCodeNeq;
  /**
   * 物流运费币种 比较(gt)
   */
  private String deliveryRealCurrencyCodeGt;
  /**
   * 物流运费币种 比较(gte)
   */
  private String deliveryRealCurrencyCodeGte;
  /**
   * 物流运费币种 比较(lt)
   */
  private String deliveryRealCurrencyCodeLt;
  /**
   * 物流运费币种 比较(lte)
   */
  private String deliveryRealCurrencyCodeLte;
  /**
   * 物流运费币种 比较(contains)
   */
  private String deliveryRealCurrencyCodeContains;
  /**
   * 物流运费币种 比较(notcontains)
   */
  private String deliveryRealCurrencyCodeNotcontains;
  /**
   * 物流运费币种 比较(startswith)
   */
  private String deliveryRealCurrencyCodeStartswith;
  /**
   * 物流运费币种 比较(endswith)
   */
  private String deliveryRealCurrencyCodeEndswith;
  /**
   * 物流运费币种 比较(isnull)
   */
  private Boolean deliveryRealCurrencyCodeIsnull;
  /**
   * 物流运费币种 比较(isnotnull)
   */
  private Boolean deliveryRealCurrencyCodeIsnotnull;

  /**
   * 物流运费币种(精确搜索)
   */
  private List<String> deliveryRealCurrencyCodeInList;

  /**
   * 物流运费
   */
  private java.math.BigDecimal deliveryRealFreight;

  /**
   * 最小物流运费
   */
  private java.math.BigDecimal deliveryRealFreightMin;

  /**
   * 最大物流运费
   */
  private java.math.BigDecimal deliveryRealFreightMax;

  /**
   * 物流运费 比较(eq)
   */
  private java.math.BigDecimal deliveryRealFreightEq;
  /**
   * 物流运费 比较(neq)
   */
  private java.math.BigDecimal deliveryRealFreightNeq;
  /**
   * 物流运费 比较(gt)
   */
  private java.math.BigDecimal deliveryRealFreightGt;
  /**
   * 物流运费 比较(gte)
   */
  private java.math.BigDecimal deliveryRealFreightGte;
  /**
   * 物流运费 比较(lt)
   */
  private java.math.BigDecimal deliveryRealFreightLt;
  /**
   * 物流运费 比较(lte)
   */
  private java.math.BigDecimal deliveryRealFreightLte;
  /**
   * 物流运费 比较(contains)
   */
  private java.math.BigDecimal deliveryRealFreightContains;
  /**
   * 物流运费 比较(notcontains)
   */
  private java.math.BigDecimal deliveryRealFreightNotcontains;
  /**
   * 物流运费 比较(startswith)
   */
  private java.math.BigDecimal deliveryRealFreightStartswith;
  /**
   * 物流运费 比较(endswith)
   */
  private java.math.BigDecimal deliveryRealFreightEndswith;
  /**
   * 物流运费 比较(isnull)
   */
  private Boolean deliveryRealFreightIsnull;
  /**
   * 物流运费 比较(isnotnull)
   */
  private Boolean deliveryRealFreightIsnotnull;

  /**
   * 物流下单状态
   */
  private String deliveryStatus;

  /**
   * 物流下单状态 比较(eq)
   */
  private String deliveryStatusEq;
  /**
   * 物流下单状态 比较(neq)
   */
  private String deliveryStatusNeq;
  /**
   * 物流下单状态 比较(gt)
   */
  private String deliveryStatusGt;
  /**
   * 物流下单状态 比较(gte)
   */
  private String deliveryStatusGte;
  /**
   * 物流下单状态 比较(lt)
   */
  private String deliveryStatusLt;
  /**
   * 物流下单状态 比较(lte)
   */
  private String deliveryStatusLte;
  /**
   * 物流下单状态 比较(contains)
   */
  private String deliveryStatusContains;
  /**
   * 物流下单状态 比较(notcontains)
   */
  private String deliveryStatusNotcontains;
  /**
   * 物流下单状态 比较(startswith)
   */
  private String deliveryStatusStartswith;
  /**
   * 物流下单状态 比较(endswith)
   */
  private String deliveryStatusEndswith;
  /**
   * 物流下单状态 比较(isnull)
   */
  private Boolean deliveryStatusIsnull;
  /**
   * 物流下单状态 比较(isnotnull)
   */
  private Boolean deliveryStatusIsnotnull;

  /**
   * 物流下单状态(精确搜索)
   */
  private List<String> deliveryStatusInList;

  /**
   * 物流下单消息(模糊搜索)
   */
  private String deliveryMessage;

  /**
   * 物流下单消息 比较(eq)
   */
  private String deliveryMessageEq;
  /**
   * 物流下单消息 比较(neq)
   */
  private String deliveryMessageNeq;
  /**
   * 物流下单消息 比较(gt)
   */
  private String deliveryMessageGt;
  /**
   * 物流下单消息 比较(gte)
   */
  private String deliveryMessageGte;
  /**
   * 物流下单消息 比较(lt)
   */
  private String deliveryMessageLt;
  /**
   * 物流下单消息 比较(lte)
   */
  private String deliveryMessageLte;
  /**
   * 物流下单消息 比较(contains)
   */
  private String deliveryMessageContains;
  /**
   * 物流下单消息 比较(notcontains)
   */
  private String deliveryMessageNotcontains;
  /**
   * 物流下单消息 比较(startswith)
   */
  private String deliveryMessageStartswith;
  /**
   * 物流下单消息 比较(endswith)
   */
  private String deliveryMessageEndswith;
  /**
   * 物流下单消息 比较(isnull)
   */
  private Boolean deliveryMessageIsnull;
  /**
   * 物流下单消息 比较(isnotnull)
   */
  private Boolean deliveryMessageIsnotnull;

  /**
   * 物流下单消息(精确搜索)
   */
  private List<String> deliveryMessageInList;

  /**
   * 物流备注(模糊搜索)
   */
  private String deliveryRemark;

  /**
   * 物流备注 比较(eq)
   */
  private String deliveryRemarkEq;
  /**
   * 物流备注 比较(neq)
   */
  private String deliveryRemarkNeq;
  /**
   * 物流备注 比较(gt)
   */
  private String deliveryRemarkGt;
  /**
   * 物流备注 比较(gte)
   */
  private String deliveryRemarkGte;
  /**
   * 物流备注 比较(lt)
   */
  private String deliveryRemarkLt;
  /**
   * 物流备注 比较(lte)
   */
  private String deliveryRemarkLte;
  /**
   * 物流备注 比较(contains)
   */
  private String deliveryRemarkContains;
  /**
   * 物流备注 比较(notcontains)
   */
  private String deliveryRemarkNotcontains;
  /**
   * 物流备注 比较(startswith)
   */
  private String deliveryRemarkStartswith;
  /**
   * 物流备注 比较(endswith)
   */
  private String deliveryRemarkEndswith;
  /**
   * 物流备注 比较(isnull)
   */
  private Boolean deliveryRemarkIsnull;
  /**
   * 物流备注 比较(isnotnull)
   */
  private Boolean deliveryRemarkIsnotnull;

  /**
   * 物流备注(精确搜索)
   */
  private List<String> deliveryRemarkInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 最早审核时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date processTimeStart;

  /**
   * 最晚审核时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date processTimeEnd;

  /**
   * 审核时间 比较(eq)
   */
  private Date processTimeEq;
  /**
   * 审核时间 比较(neq)
   */
  private Date processTimeNeq;
  /**
   * 审核时间 比较(gt)
   */
  private Date processTimeGt;
  /**
   * 审核时间 比较(gte)
   */
  private Date processTimeGte;
  /**
   * 审核时间 比较(lt)
   */
  private Date processTimeLt;
  /**
   * 审核时间 比较(lte)
   */
  private Date processTimeLte;
  /**
   * 审核时间 比较(contains)
   */
  private Date processTimeContains;
  /**
   * 审核时间 比较(notcontains)
   */
  private Date processTimeNotcontains;
  /**
   * 审核时间 比较(startswith)
   */
  private Date processTimeStartswith;
  /**
   * 审核时间 比较(endswith)
   */
  private Date processTimeEndswith;
  /**
   * 审核时间 比较(isnull)
   */
  private Boolean processTimeIsnull;
  /**
   * 审核时间 比较(isnotnull)
   */
  private Boolean processTimeIsnotnull;

  /**
   * 最早配货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date distributionTimeStart;

  /**
   * 最晚配货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date distributionTimeEnd;

  /**
   * 配货时间 比较(eq)
   */
  private Date distributionTimeEq;
  /**
   * 配货时间 比较(neq)
   */
  private Date distributionTimeNeq;
  /**
   * 配货时间 比较(gt)
   */
  private Date distributionTimeGt;
  /**
   * 配货时间 比较(gte)
   */
  private Date distributionTimeGte;
  /**
   * 配货时间 比较(lt)
   */
  private Date distributionTimeLt;
  /**
   * 配货时间 比较(lte)
   */
  private Date distributionTimeLte;
  /**
   * 配货时间 比较(contains)
   */
  private Date distributionTimeContains;
  /**
   * 配货时间 比较(notcontains)
   */
  private Date distributionTimeNotcontains;
  /**
   * 配货时间 比较(startswith)
   */
  private Date distributionTimeStartswith;
  /**
   * 配货时间 比较(endswith)
   */
  private Date distributionTimeEndswith;
  /**
   * 配货时间 比较(isnull)
   */
  private Boolean distributionTimeIsnull;
  /**
   * 配货时间 比较(isnotnull)
   */
  private Boolean distributionTimeIsnotnull;

  /**
   * 最早打单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickingTimeStart;

  /**
   * 最晚打单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickingTimeEnd;

  /**
   * 打单时间 比较(eq)
   */
  private Date pickingTimeEq;
  /**
   * 打单时间 比较(neq)
   */
  private Date pickingTimeNeq;
  /**
   * 打单时间 比较(gt)
   */
  private Date pickingTimeGt;
  /**
   * 打单时间 比较(gte)
   */
  private Date pickingTimeGte;
  /**
   * 打单时间 比较(lt)
   */
  private Date pickingTimeLt;
  /**
   * 打单时间 比较(lte)
   */
  private Date pickingTimeLte;
  /**
   * 打单时间 比较(contains)
   */
  private Date pickingTimeContains;
  /**
   * 打单时间 比较(notcontains)
   */
  private Date pickingTimeNotcontains;
  /**
   * 打单时间 比较(startswith)
   */
  private Date pickingTimeStartswith;
  /**
   * 打单时间 比较(endswith)
   */
  private Date pickingTimeEndswith;
  /**
   * 打单时间 比较(isnull)
   */
  private Boolean pickingTimeIsnull;
  /**
   * 打单时间 比较(isnotnull)
   */
  private Boolean pickingTimeIsnotnull;

  /**
   * 最早尾款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date tailTimeStart;

  /**
   * 最晚尾款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date tailTimeEnd;

  /**
   * 尾款时间 比较(eq)
   */
  private Date tailTimeEq;
  /**
   * 尾款时间 比较(neq)
   */
  private Date tailTimeNeq;
  /**
   * 尾款时间 比较(gt)
   */
  private Date tailTimeGt;
  /**
   * 尾款时间 比较(gte)
   */
  private Date tailTimeGte;
  /**
   * 尾款时间 比较(lt)
   */
  private Date tailTimeLt;
  /**
   * 尾款时间 比较(lte)
   */
  private Date tailTimeLte;
  /**
   * 尾款时间 比较(contains)
   */
  private Date tailTimeContains;
  /**
   * 尾款时间 比较(notcontains)
   */
  private Date tailTimeNotcontains;
  /**
   * 尾款时间 比较(startswith)
   */
  private Date tailTimeStartswith;
  /**
   * 尾款时间 比较(endswith)
   */
  private Date tailTimeEndswith;
  /**
   * 尾款时间 比较(isnull)
   */
  private Boolean tailTimeIsnull;
  /**
   * 尾款时间 比较(isnotnull)
   */
  private Boolean tailTimeIsnotnull;

  /**
   * 截单状态
   */
  private String cutStatus;

  /**
   * 截单状态 比较(eq)
   */
  private String cutStatusEq;
  /**
   * 截单状态 比较(neq)
   */
  private String cutStatusNeq;
  /**
   * 截单状态 比较(gt)
   */
  private String cutStatusGt;
  /**
   * 截单状态 比较(gte)
   */
  private String cutStatusGte;
  /**
   * 截单状态 比较(lt)
   */
  private String cutStatusLt;
  /**
   * 截单状态 比较(lte)
   */
  private String cutStatusLte;
  /**
   * 截单状态 比较(contains)
   */
  private String cutStatusContains;
  /**
   * 截单状态 比较(notcontains)
   */
  private String cutStatusNotcontains;
  /**
   * 截单状态 比较(startswith)
   */
  private String cutStatusStartswith;
  /**
   * 截单状态 比较(endswith)
   */
  private String cutStatusEndswith;
  /**
   * 截单状态 比较(isnull)
   */
  private Boolean cutStatusIsnull;
  /**
   * 截单状态 比较(isnotnull)
   */
  private Boolean cutStatusIsnotnull;

  /**
   * 截单状态(精确搜索)
   */
  private List<String> cutStatusInList;

  /**
   * 配货状态
   */
  private String distributionStatus;

  /**
   * 配货状态 比较(eq)
   */
  private String distributionStatusEq;
  /**
   * 配货状态 比较(neq)
   */
  private String distributionStatusNeq;
  /**
   * 配货状态 比较(gt)
   */
  private String distributionStatusGt;
  /**
   * 配货状态 比较(gte)
   */
  private String distributionStatusGte;
  /**
   * 配货状态 比较(lt)
   */
  private String distributionStatusLt;
  /**
   * 配货状态 比较(lte)
   */
  private String distributionStatusLte;
  /**
   * 配货状态 比较(contains)
   */
  private String distributionStatusContains;
  /**
   * 配货状态 比较(notcontains)
   */
  private String distributionStatusNotcontains;
  /**
   * 配货状态 比较(startswith)
   */
  private String distributionStatusStartswith;
  /**
   * 配货状态 比较(endswith)
   */
  private String distributionStatusEndswith;
  /**
   * 配货状态 比较(isnull)
   */
  private Boolean distributionStatusIsnull;
  /**
   * 配货状态 比较(isnotnull)
   */
  private Boolean distributionStatusIsnotnull;

  /**
   * 配货状态(精确搜索)
   */
  private List<String> distributionStatusInList;

  /**
   * 面单打印
   */
  private String printFaceStatus;

  /**
   * 面单打印 比较(eq)
   */
  private String printFaceStatusEq;
  /**
   * 面单打印 比较(neq)
   */
  private String printFaceStatusNeq;
  /**
   * 面单打印 比较(gt)
   */
  private String printFaceStatusGt;
  /**
   * 面单打印 比较(gte)
   */
  private String printFaceStatusGte;
  /**
   * 面单打印 比较(lt)
   */
  private String printFaceStatusLt;
  /**
   * 面单打印 比较(lte)
   */
  private String printFaceStatusLte;
  /**
   * 面单打印 比较(contains)
   */
  private String printFaceStatusContains;
  /**
   * 面单打印 比较(notcontains)
   */
  private String printFaceStatusNotcontains;
  /**
   * 面单打印 比较(startswith)
   */
  private String printFaceStatusStartswith;
  /**
   * 面单打印 比较(endswith)
   */
  private String printFaceStatusEndswith;
  /**
   * 面单打印 比较(isnull)
   */
  private Boolean printFaceStatusIsnull;
  /**
   * 面单打印 比较(isnotnull)
   */
  private Boolean printFaceStatusIsnotnull;

  /**
   * 面单打印(精确搜索)
   */
  private List<String> printFaceStatusInList;

  /**
   * 拣货单打印
   */
  private String printOrderStatus;

  /**
   * 拣货单打印 比较(eq)
   */
  private String printOrderStatusEq;
  /**
   * 拣货单打印 比较(neq)
   */
  private String printOrderStatusNeq;
  /**
   * 拣货单打印 比较(gt)
   */
  private String printOrderStatusGt;
  /**
   * 拣货单打印 比较(gte)
   */
  private String printOrderStatusGte;
  /**
   * 拣货单打印 比较(lt)
   */
  private String printOrderStatusLt;
  /**
   * 拣货单打印 比较(lte)
   */
  private String printOrderStatusLte;
  /**
   * 拣货单打印 比较(contains)
   */
  private String printOrderStatusContains;
  /**
   * 拣货单打印 比较(notcontains)
   */
  private String printOrderStatusNotcontains;
  /**
   * 拣货单打印 比较(startswith)
   */
  private String printOrderStatusStartswith;
  /**
   * 拣货单打印 比较(endswith)
   */
  private String printOrderStatusEndswith;
  /**
   * 拣货单打印 比较(isnull)
   */
  private Boolean printOrderStatusIsnull;
  /**
   * 拣货单打印 比较(isnotnull)
   */
  private Boolean printOrderStatusIsnotnull;

  /**
   * 拣货单打印(精确搜索)
   */
  private List<String> printOrderStatusInList;

  /**
   * 是否验货
   */
  private String isTest;

  /**
   * 是否验货 比较(eq)
   */
  private String isTestEq;
  /**
   * 是否验货 比较(neq)
   */
  private String isTestNeq;
  /**
   * 是否验货 比较(gt)
   */
  private String isTestGt;
  /**
   * 是否验货 比较(gte)
   */
  private String isTestGte;
  /**
   * 是否验货 比较(lt)
   */
  private String isTestLt;
  /**
   * 是否验货 比较(lte)
   */
  private String isTestLte;
  /**
   * 是否验货 比较(contains)
   */
  private String isTestContains;
  /**
   * 是否验货 比较(notcontains)
   */
  private String isTestNotcontains;
  /**
   * 是否验货 比较(startswith)
   */
  private String isTestStartswith;
  /**
   * 是否验货 比较(endswith)
   */
  private String isTestEndswith;
  /**
   * 是否验货 比较(isnull)
   */
  private Boolean isTestIsnull;
  /**
   * 是否验货 比较(isnotnull)
   */
  private Boolean isTestIsnotnull;

  /**
   * 是否验货(精确搜索)
   */
  private List<String> isTestInList;

  /**
   * 是否称重
   */
  private String isWeigh;

  /**
   * 是否称重 比较(eq)
   */
  private String isWeighEq;
  /**
   * 是否称重 比较(neq)
   */
  private String isWeighNeq;
  /**
   * 是否称重 比较(gt)
   */
  private String isWeighGt;
  /**
   * 是否称重 比较(gte)
   */
  private String isWeighGte;
  /**
   * 是否称重 比较(lt)
   */
  private String isWeighLt;
  /**
   * 是否称重 比较(lte)
   */
  private String isWeighLte;
  /**
   * 是否称重 比较(contains)
   */
  private String isWeighContains;
  /**
   * 是否称重 比较(notcontains)
   */
  private String isWeighNotcontains;
  /**
   * 是否称重 比较(startswith)
   */
  private String isWeighStartswith;
  /**
   * 是否称重 比较(endswith)
   */
  private String isWeighEndswith;
  /**
   * 是否称重 比较(isnull)
   */
  private Boolean isWeighIsnull;
  /**
   * 是否称重 比较(isnotnull)
   */
  private Boolean isWeighIsnotnull;

  /**
   * 是否称重(精确搜索)
   */
  private List<String> isWeighInList;

  /**
   * 销售出库单号(模糊搜索)
   */
  private String woNumber;

  /**
   * 销售出库单号 比较(eq)
   */
  private String woNumberEq;
  /**
   * 销售出库单号 比较(neq)
   */
  private String woNumberNeq;
  /**
   * 销售出库单号 比较(gt)
   */
  private String woNumberGt;
  /**
   * 销售出库单号 比较(gte)
   */
  private String woNumberGte;
  /**
   * 销售出库单号 比较(lt)
   */
  private String woNumberLt;
  /**
   * 销售出库单号 比较(lte)
   */
  private String woNumberLte;
  /**
   * 销售出库单号 比较(contains)
   */
  private String woNumberContains;
  /**
   * 销售出库单号 比较(notcontains)
   */
  private String woNumberNotcontains;
  /**
   * 销售出库单号 比较(startswith)
   */
  private String woNumberStartswith;
  /**
   * 销售出库单号 比较(endswith)
   */
  private String woNumberEndswith;
  /**
   * 销售出库单号 比较(isnull)
   */
  private Boolean woNumberIsnull;
  /**
   * 销售出库单号 比较(isnotnull)
   */
  private Boolean woNumberIsnotnull;

  /**
   * 销售出库单号(精确搜索)
   */
  private List<String> woNumberInList;

  /**
   * 销售出库单Id
   */
  private Long wmsOrderId;

  /**
   * 最小销售出库单Id
   */
  private Long wmsOrderIdMin;

  /**
   * 最大销售出库单Id
   */
  private Long wmsOrderIdMax;

  /**
   * 销售出库单Id 比较(eq)
   */
  private Long wmsOrderIdEq;
  /**
   * 销售出库单Id 比较(neq)
   */
  private Long wmsOrderIdNeq;
  /**
   * 销售出库单Id 比较(gt)
   */
  private Long wmsOrderIdGt;
  /**
   * 销售出库单Id 比较(gte)
   */
  private Long wmsOrderIdGte;
  /**
   * 销售出库单Id 比较(lt)
   */
  private Long wmsOrderIdLt;
  /**
   * 销售出库单Id 比较(lte)
   */
  private Long wmsOrderIdLte;
  /**
   * 销售出库单Id 比较(contains)
   */
  private Long wmsOrderIdContains;
  /**
   * 销售出库单Id 比较(notcontains)
   */
  private Long wmsOrderIdNotcontains;
  /**
   * 销售出库单Id 比较(startswith)
   */
  private Long wmsOrderIdStartswith;
  /**
   * 销售出库单Id 比较(endswith)
   */
  private Long wmsOrderIdEndswith;
  /**
   * 销售出库单Id 比较(isnull)
   */
  private Boolean wmsOrderIdIsnull;
  /**
   * 销售出库单Id 比较(isnotnull)
   */
  private Boolean wmsOrderIdIsnotnull;

  /**
   * 波次号(模糊搜索)
   */
  private String boxId;

  /**
   * 波次号 比较(eq)
   */
  private String boxIdEq;
  /**
   * 波次号 比较(neq)
   */
  private String boxIdNeq;
  /**
   * 波次号 比较(gt)
   */
  private String boxIdGt;
  /**
   * 波次号 比较(gte)
   */
  private String boxIdGte;
  /**
   * 波次号 比较(lt)
   */
  private String boxIdLt;
  /**
   * 波次号 比较(lte)
   */
  private String boxIdLte;
  /**
   * 波次号 比较(contains)
   */
  private String boxIdContains;
  /**
   * 波次号 比较(notcontains)
   */
  private String boxIdNotcontains;
  /**
   * 波次号 比较(startswith)
   */
  private String boxIdStartswith;
  /**
   * 波次号 比较(endswith)
   */
  private String boxIdEndswith;
  /**
   * 波次号 比较(isnull)
   */
  private Boolean boxIdIsnull;
  /**
   * 波次号 比较(isnotnull)
   */
  private Boolean boxIdIsnotnull;

  /**
   * 波次号(精确搜索)
   */
  private List<String> boxIdInList;

  /**
   * 最早发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickingDeliveryTimeStart;

  /**
   * 最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickingDeliveryTimeEnd;

  /**
   * 发货时间 比较(eq)
   */
  private Date pickingDeliveryTimeEq;
  /**
   * 发货时间 比较(neq)
   */
  private Date pickingDeliveryTimeNeq;
  /**
   * 发货时间 比较(gt)
   */
  private Date pickingDeliveryTimeGt;
  /**
   * 发货时间 比较(gte)
   */
  private Date pickingDeliveryTimeGte;
  /**
   * 发货时间 比较(lt)
   */
  private Date pickingDeliveryTimeLt;
  /**
   * 发货时间 比较(lte)
   */
  private Date pickingDeliveryTimeLte;
  /**
   * 发货时间 比较(contains)
   */
  private Date pickingDeliveryTimeContains;
  /**
   * 发货时间 比较(notcontains)
   */
  private Date pickingDeliveryTimeNotcontains;
  /**
   * 发货时间 比较(startswith)
   */
  private Date pickingDeliveryTimeStartswith;
  /**
   * 发货时间 比较(endswith)
   */
  private Date pickingDeliveryTimeEndswith;
  /**
   * 发货时间 比较(isnull)
   */
  private Boolean pickingDeliveryTimeIsnull;
  /**
   * 发货时间 比较(isnotnull)
   */
  private Boolean pickingDeliveryTimeIsnotnull;

  /**
   * 物流商(模糊搜索)
   */
  private String providerName;

  /**
   * 物流商 比较(eq)
   */
  private String providerNameEq;
  /**
   * 物流商 比较(neq)
   */
  private String providerNameNeq;
  /**
   * 物流商 比较(gt)
   */
  private String providerNameGt;
  /**
   * 物流商 比较(gte)
   */
  private String providerNameGte;
  /**
   * 物流商 比较(lt)
   */
  private String providerNameLt;
  /**
   * 物流商 比较(lte)
   */
  private String providerNameLte;
  /**
   * 物流商 比较(contains)
   */
  private String providerNameContains;
  /**
   * 物流商 比较(notcontains)
   */
  private String providerNameNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private String providerNameStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private String providerNameEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean providerNameIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean providerNameIsnotnull;

  /**
   * 物流商(精确搜索)
   */
  private List<String> providerNameInList;

  /**
   * 库存扣减类型
   */
  private String warehouseActInventoryDeductionType;

  /**
   * 库存扣减类型 比较(eq)
   */
  private String warehouseActInventoryDeductionTypeEq;
  /**
   * 库存扣减类型 比较(neq)
   */
  private String warehouseActInventoryDeductionTypeNeq;
  /**
   * 库存扣减类型 比较(gt)
   */
  private String warehouseActInventoryDeductionTypeGt;
  /**
   * 库存扣减类型 比较(gte)
   */
  private String warehouseActInventoryDeductionTypeGte;
  /**
   * 库存扣减类型 比较(lt)
   */
  private String warehouseActInventoryDeductionTypeLt;
  /**
   * 库存扣减类型 比较(lte)
   */
  private String warehouseActInventoryDeductionTypeLte;
  /**
   * 库存扣减类型 比较(contains)
   */
  private String warehouseActInventoryDeductionTypeContains;
  /**
   * 库存扣减类型 比较(notcontains)
   */
  private String warehouseActInventoryDeductionTypeNotcontains;
  /**
   * 库存扣减类型 比较(startswith)
   */
  private String warehouseActInventoryDeductionTypeStartswith;
  /**
   * 库存扣减类型 比较(endswith)
   */
  private String warehouseActInventoryDeductionTypeEndswith;
  /**
   * 库存扣减类型 比较(isnull)
   */
  private Boolean warehouseActInventoryDeductionTypeIsnull;
  /**
   * 库存扣减类型 比较(isnotnull)
   */
  private Boolean warehouseActInventoryDeductionTypeIsnotnull;

  /**
   * 库存扣减类型(精确搜索)
   */
  private List<String> warehouseActInventoryDeductionTypeInList;

  /**
   * 物流下单状态
   */
  private String logisticsOrderStatus;

  /**
   * 物流下单状态 比较(eq)
   */
  private String logisticsOrderStatusEq;
  /**
   * 物流下单状态 比较(neq)
   */
  private String logisticsOrderStatusNeq;
  /**
   * 物流下单状态 比较(gt)
   */
  private String logisticsOrderStatusGt;
  /**
   * 物流下单状态 比较(gte)
   */
  private String logisticsOrderStatusGte;
  /**
   * 物流下单状态 比较(lt)
   */
  private String logisticsOrderStatusLt;
  /**
   * 物流下单状态 比较(lte)
   */
  private String logisticsOrderStatusLte;
  /**
   * 物流下单状态 比较(contains)
   */
  private String logisticsOrderStatusContains;
  /**
   * 物流下单状态 比较(notcontains)
   */
  private String logisticsOrderStatusNotcontains;
  /**
   * 物流下单状态 比较(startswith)
   */
  private String logisticsOrderStatusStartswith;
  /**
   * 物流下单状态 比较(endswith)
   */
  private String logisticsOrderStatusEndswith;
  /**
   * 物流下单状态 比较(isnull)
   */
  private Boolean logisticsOrderStatusIsnull;
  /**
   * 物流下单状态 比较(isnotnull)
   */
  private Boolean logisticsOrderStatusIsnotnull;

  /**
   * 物流下单状态(精确搜索)
   */
  private List<String> logisticsOrderStatusInList;

  /**
   * 异常信息(模糊搜索)
   */
  private String errorMessage;

  /**
   * 异常信息 比较(eq)
   */
  private String errorMessageEq;
  /**
   * 异常信息 比较(neq)
   */
  private String errorMessageNeq;
  /**
   * 异常信息 比较(gt)
   */
  private String errorMessageGt;
  /**
   * 异常信息 比较(gte)
   */
  private String errorMessageGte;
  /**
   * 异常信息 比较(lt)
   */
  private String errorMessageLt;
  /**
   * 异常信息 比较(lte)
   */
  private String errorMessageLte;
  /**
   * 异常信息 比较(contains)
   */
  private String errorMessageContains;
  /**
   * 异常信息 比较(notcontains)
   */
  private String errorMessageNotcontains;
  /**
   * 异常信息 比较(startswith)
   */
  private String errorMessageStartswith;
  /**
   * 异常信息 比较(endswith)
   */
  private String errorMessageEndswith;
  /**
   * 异常信息 比较(isnull)
   */
  private Boolean errorMessageIsnull;
  /**
   * 异常信息 比较(isnotnull)
   */
  private Boolean errorMessageIsnotnull;

  /**
   * 异常信息(精确搜索)
   */
  private List<String> errorMessageInList;

  /**
   * 解决方案(模糊搜索)
   */
  private String solution;

  /**
   * 解决方案 比较(eq)
   */
  private String solutionEq;
  /**
   * 解决方案 比较(neq)
   */
  private String solutionNeq;
  /**
   * 解决方案 比较(gt)
   */
  private String solutionGt;
  /**
   * 解决方案 比较(gte)
   */
  private String solutionGte;
  /**
   * 解决方案 比较(lt)
   */
  private String solutionLt;
  /**
   * 解决方案 比较(lte)
   */
  private String solutionLte;
  /**
   * 解决方案 比较(contains)
   */
  private String solutionContains;
  /**
   * 解决方案 比较(notcontains)
   */
  private String solutionNotcontains;
  /**
   * 解决方案 比较(startswith)
   */
  private String solutionStartswith;
  /**
   * 解决方案 比较(endswith)
   */
  private String solutionEndswith;
  /**
   * 解决方案 比较(isnull)
   */
  private Boolean solutionIsnull;
  /**
   * 解决方案 比较(isnotnull)
   */
  private Boolean solutionIsnotnull;

  /**
   * 解决方案(精确搜索)
   */
  private List<String> solutionInList;

  /**
   * 线上状态(模糊搜索)
   */
  private String onlineStatus;

  /**
   * 线上状态 比较(eq)
   */
  private String onlineStatusEq;
  /**
   * 线上状态 比较(neq)
   */
  private String onlineStatusNeq;
  /**
   * 线上状态 比较(gt)
   */
  private String onlineStatusGt;
  /**
   * 线上状态 比较(gte)
   */
  private String onlineStatusGte;
  /**
   * 线上状态 比较(lt)
   */
  private String onlineStatusLt;
  /**
   * 线上状态 比较(lte)
   */
  private String onlineStatusLte;
  /**
   * 线上状态 比较(contains)
   */
  private String onlineStatusContains;
  /**
   * 线上状态 比较(notcontains)
   */
  private String onlineStatusNotcontains;
  /**
   * 线上状态 比较(startswith)
   */
  private String onlineStatusStartswith;
  /**
   * 线上状态 比较(endswith)
   */
  private String onlineStatusEndswith;
  /**
   * 线上状态 比较(isnull)
   */
  private Boolean onlineStatusIsnull;
  /**
   * 线上状态 比较(isnotnull)
   */
  private Boolean onlineStatusIsnotnull;

  /**
   * 线上状态(精确搜索)
   */
  private List<String> onlineStatusInList;

  /**
   * 标发状态
   */
  private String issuStatus;

  /**
   * 标发状态 比较(eq)
   */
  private String issuStatusEq;
  /**
   * 标发状态 比较(neq)
   */
  private String issuStatusNeq;
  /**
   * 标发状态 比较(gt)
   */
  private String issuStatusGt;
  /**
   * 标发状态 比较(gte)
   */
  private String issuStatusGte;
  /**
   * 标发状态 比较(lt)
   */
  private String issuStatusLt;
  /**
   * 标发状态 比较(lte)
   */
  private String issuStatusLte;
  /**
   * 标发状态 比较(contains)
   */
  private String issuStatusContains;
  /**
   * 标发状态 比较(notcontains)
   */
  private String issuStatusNotcontains;
  /**
   * 标发状态 比较(startswith)
   */
  private String issuStatusStartswith;
  /**
   * 标发状态 比较(endswith)
   */
  private String issuStatusEndswith;
  /**
   * 标发状态 比较(isnull)
   */
  private Boolean issuStatusIsnull;
  /**
   * 标发状态 比较(isnotnull)
   */
  private Boolean issuStatusIsnotnull;

  /**
   * 标发状态(精确搜索)
   */
  private List<String> issuStatusInList;

  /**
   * 标发状态内容(模糊搜索)
   */
  private String issuStatusExplain;

  /**
   * 标发状态内容 比较(eq)
   */
  private String issuStatusExplainEq;
  /**
   * 标发状态内容 比较(neq)
   */
  private String issuStatusExplainNeq;
  /**
   * 标发状态内容 比较(gt)
   */
  private String issuStatusExplainGt;
  /**
   * 标发状态内容 比较(gte)
   */
  private String issuStatusExplainGte;
  /**
   * 标发状态内容 比较(lt)
   */
  private String issuStatusExplainLt;
  /**
   * 标发状态内容 比较(lte)
   */
  private String issuStatusExplainLte;
  /**
   * 标发状态内容 比较(contains)
   */
  private String issuStatusExplainContains;
  /**
   * 标发状态内容 比较(notcontains)
   */
  private String issuStatusExplainNotcontains;
  /**
   * 标发状态内容 比较(startswith)
   */
  private String issuStatusExplainStartswith;
  /**
   * 标发状态内容 比较(endswith)
   */
  private String issuStatusExplainEndswith;
  /**
   * 标发状态内容 比较(isnull)
   */
  private Boolean issuStatusExplainIsnull;
  /**
   * 标发状态内容 比较(isnotnull)
   */
  private Boolean issuStatusExplainIsnotnull;

  /**
   * 标发状态内容(精确搜索)
   */
  private List<String> issuStatusExplainInList;

  /**
   * 标发次数
   */
  private Integer issuNumber;

  /**
   * 最小标发次数
   */
  private Integer issuNumberMin;

  /**
   * 最大标发次数
   */
  private Integer issuNumberMax;

  /**
   * 标发次数 比较(eq)
   */
  private Integer issuNumberEq;
  /**
   * 标发次数 比较(neq)
   */
  private Integer issuNumberNeq;
  /**
   * 标发次数 比较(gt)
   */
  private Integer issuNumberGt;
  /**
   * 标发次数 比较(gte)
   */
  private Integer issuNumberGte;
  /**
   * 标发次数 比较(lt)
   */
  private Integer issuNumberLt;
  /**
   * 标发次数 比较(lte)
   */
  private Integer issuNumberLte;
  /**
   * 标发次数 比较(contains)
   */
  private Integer issuNumberContains;
  /**
   * 标发次数 比较(notcontains)
   */
  private Integer issuNumberNotcontains;
  /**
   * 标发次数 比较(startswith)
   */
  private Integer issuNumberStartswith;
  /**
   * 标发次数 比较(endswith)
   */
  private Integer issuNumberEndswith;
  /**
   * 标发次数 比较(isnull)
   */
  private Boolean issuNumberIsnull;
  /**
   * 标发次数 比较(isnotnull)
   */
  private Boolean issuNumberIsnotnull;

  /**
   * 标发规则
   */
  private String issuActRules;

  /**
   * 标发规则 比较(eq)
   */
  private String issuActRulesEq;
  /**
   * 标发规则 比较(neq)
   */
  private String issuActRulesNeq;
  /**
   * 标发规则 比较(gt)
   */
  private String issuActRulesGt;
  /**
   * 标发规则 比较(gte)
   */
  private String issuActRulesGte;
  /**
   * 标发规则 比较(lt)
   */
  private String issuActRulesLt;
  /**
   * 标发规则 比较(lte)
   */
  private String issuActRulesLte;
  /**
   * 标发规则 比较(contains)
   */
  private String issuActRulesContains;
  /**
   * 标发规则 比较(notcontains)
   */
  private String issuActRulesNotcontains;
  /**
   * 标发规则 比较(startswith)
   */
  private String issuActRulesStartswith;
  /**
   * 标发规则 比较(endswith)
   */
  private String issuActRulesEndswith;
  /**
   * 标发规则 比较(isnull)
   */
  private Boolean issuActRulesIsnull;
  /**
   * 标发规则 比较(isnotnull)
   */
  private Boolean issuActRulesIsnotnull;

  /**
   * 标发规则(精确搜索)
   */
  private List<String> issuActRulesInList;

  /**
   * 配对关系应用到其他待审核订单和商品配对
   */
  private String pariLike;

  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(eq)
   */
  private String pariLikeEq;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(neq)
   */
  private String pariLikeNeq;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(gt)
   */
  private String pariLikeGt;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(gte)
   */
  private String pariLikeGte;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(lt)
   */
  private String pariLikeLt;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(lte)
   */
  private String pariLikeLte;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(contains)
   */
  private String pariLikeContains;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(notcontains)
   */
  private String pariLikeNotcontains;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(startswith)
   */
  private String pariLikeStartswith;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(endswith)
   */
  private String pariLikeEndswith;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(isnull)
   */
  private Boolean pariLikeIsnull;
  /**
   * 配对关系应用到其他待审核订单和商品配对 比较(isnotnull)
   */
  private Boolean pariLikeIsnotnull;

  /**
   * 配对关系应用到其他待审核订单和商品配对(精确搜索)
   */
  private List<String> pariLikeInList;

  /**
   * 包裹ids(模糊搜索)
   */
  private String packageIds;

  /**
   * 包裹ids 比较(eq)
   */
  private String packageIdsEq;
  /**
   * 包裹ids 比较(neq)
   */
  private String packageIdsNeq;
  /**
   * 包裹ids 比较(gt)
   */
  private String packageIdsGt;
  /**
   * 包裹ids 比较(gte)
   */
  private String packageIdsGte;
  /**
   * 包裹ids 比较(lt)
   */
  private String packageIdsLt;
  /**
   * 包裹ids 比较(lte)
   */
  private String packageIdsLte;
  /**
   * 包裹ids 比较(contains)
   */
  private String packageIdsContains;
  /**
   * 包裹ids 比较(notcontains)
   */
  private String packageIdsNotcontains;
  /**
   * 包裹ids 比较(startswith)
   */
  private String packageIdsStartswith;
  /**
   * 包裹ids 比较(endswith)
   */
  private String packageIdsEndswith;
  /**
   * 包裹ids 比较(isnull)
   */
  private Boolean packageIdsIsnull;
  /**
   * 包裹ids 比较(isnotnull)
   */
  private Boolean packageIdsIsnotnull;

  /**
   * 包裹ids(精确搜索)
   */
  private List<String> packageIdsInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
